mirror of https://gitee.com/bigwinds/arangodb
474 lines
20 KiB
C
Executable File
474 lines
20 KiB
C
Executable File
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief vector implementation
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2004-2012 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler
|
|
/// @author Copyright 2011-2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef TRIAGENS_BASICS_C_VECTOR_H
|
|
#define TRIAGENS_BASICS_C_VECTOR_H 1
|
|
|
|
#include "BasicsC/common.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- POD VECTORS
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public types
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief pod vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct TRI_vector_s {
|
|
TRI_memory_zone_t* _memoryZone;
|
|
size_t _elementSize;
|
|
char * _buffer;
|
|
size_t _length;
|
|
size_t _capacity;
|
|
}
|
|
TRI_vector_t;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_InitVector (TRI_vector_t*, TRI_memory_zone_t*, size_t elementSize);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a vector, with user-definable settings
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InitVector2 (TRI_vector_t*,
|
|
TRI_memory_zone_t*,
|
|
size_t elementSize,
|
|
size_t initialCapacity);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_DestroyVector (TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector and frees the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeVector (TRI_memory_zone_t* zone, TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief copies a vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRI_vector_t* TRI_CopyVector (TRI_memory_zone_t*, TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief copy data from one vector into another
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_CopyDataVector (TRI_vector_t*, const TRI_vector_t* const);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns true if the vector is empty
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool TRI_EmptyVector (TRI_vector_t const*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clears the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_ClearVector (TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resizes the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_ResizeVector (TRI_vector_t*, size_t n);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds and element at the end
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_PushBackVector (TRI_vector_t*, void const* element);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_RemoveVector (TRI_vector_t*, size_t n);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the element at a given position
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_AtVector (TRI_vector_t const*, size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief inserts an element at a given position
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_InsertVector (TRI_vector_t* vector, void const* element, size_t position);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sets an element at a given position
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_SetVector (TRI_vector_t* vector, size_t, void const* element);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the beginning
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_BeginVector (TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the end (pointer after the last element)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_EndVector (TRI_vector_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- POINTER VECTORS
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public types
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief pointer vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct TRI_vector_pointer_s {
|
|
TRI_memory_zone_t* _memoryZone;
|
|
void** _buffer;
|
|
size_t _length;
|
|
size_t _capacity;
|
|
}
|
|
TRI_vector_pointer_t;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_InitVectorPointer (TRI_vector_pointer_t*, TRI_memory_zone_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a vector, with user-definable settings
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InitVectorPointer2 (TRI_vector_pointer_t*,
|
|
TRI_memory_zone_t*,
|
|
size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_DestroyVectorPointer (TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector and frees the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeVectorPointer (TRI_memory_zone_t*, TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector and frees the pointer and the content
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeContentVectorPointer (TRI_memory_zone_t*,
|
|
TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief copies a vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRI_vector_pointer_t* TRI_CopyVectorPointer (TRI_memory_zone_t*, TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief copies all pointers from a vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_CopyDataVectorPointer (TRI_vector_pointer_t*, TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns true if the vector is empty
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool TRI_EmptyVectorPointer (TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clears the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_ClearVectorPointer (TRI_vector_pointer_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resizes the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_ResizeVectorPointer (TRI_vector_pointer_t*, size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds an element at the end
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_PushBackVectorPointer (TRI_vector_pointer_t*, void*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds an element at position n
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InsertVectorPointer (TRI_vector_pointer_t*, void*, size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element, returns this element
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_RemoveVectorPointer (TRI_vector_pointer_t*, size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the element at a given position
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_AtVectorPointer (TRI_vector_pointer_t const*, size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- STRING VECTORS
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public types
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief string vector
|
|
///
|
|
/// Destroying a string vector will also free all strings stored inside the
|
|
/// vector.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct TRI_vector_string_s {
|
|
TRI_memory_zone_t* _memoryZone;
|
|
char** _buffer;
|
|
size_t _length;
|
|
size_t _capacity;
|
|
}
|
|
TRI_vector_string_t;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a string vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_InitVectorString (TRI_vector_string_t*, TRI_memory_zone_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises a string vector, with user-definable settings
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InitVectorString2 (TRI_vector_string_t*,
|
|
TRI_memory_zone_t*,
|
|
size_t);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector and all strings, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_DestroyVectorString (TRI_vector_string_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a vector and frees the string
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeVectorString (TRI_memory_zone_t*, TRI_vector_string_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup Collections
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief copies a vector and all its strings
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRI_vector_string_t* TRI_CopyVectorString (TRI_memory_zone_t*, TRI_vector_string_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns true if the vector is empty
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool TRI_EmptyVectorString (TRI_vector_string_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clears the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_ClearVectorString (TRI_vector_string_t*);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resizes the vector
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_ResizeVectorString (TRI_vector_string_t*, size_t n);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds an element at the end
|
|
///
|
|
/// Note that the vector claims owenship of element.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_PushBackVectorString (TRI_vector_string_t*, char* element);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds an element at position n
|
|
///
|
|
/// Note that the vector claims owenship of element.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InsertVectorString (TRI_vector_string_t*, char* element, size_t n);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element, frees this element
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_RemoveVectorString (TRI_vector_string_t*, size_t n);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)"
|
|
// End:
|