//////////////////////////////////////////////////////////////////////////////// /// DISCLAIMER /// /// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany /// Copyright 2004-2014 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 ArangoDB GmbH, Cologne, Germany /// /// @author Dr. Frank Celler //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGODB_BASICS_VECTOR_H #define ARANGODB_BASICS_VECTOR_H 1 #include "Basics/Common.h" //////////////////////////////////////////////////////////////////////////////// /// @brief pod vector //////////////////////////////////////////////////////////////////////////////// typedef struct TRI_vector_s { char* _buffer; TRI_memory_zone_id_t _memoryZoneX; // private. do not access from outside uint32_t _lengthX; // private. do not access from outside! uint32_t _capacityX; // private. do not access from outside! uint32_t _elementSizeX; // private. do not access from outside! } TRI_vector_t; static_assert(sizeof(TRI_memory_zone_id_t) == 4, "invalid size for TRI_memory_zone_id_t"); static_assert(sizeof(TRI_vector_t) == sizeof(char*) + 4 * sizeof(uint32_t), "invalid size for TRI_vector_t"); //////////////////////////////////////////////////////////////////////////////// /// @brief initializes a vector //////////////////////////////////////////////////////////////////////////////// void TRI_InitVector(TRI_vector_t*, TRI_memory_zone_t*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief initializes a vector, with user-definable settings //////////////////////////////////////////////////////////////////////////////// int TRI_InitVector2(TRI_vector_t*, TRI_memory_zone_t*, size_t, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief destroys a vector, but does not free the pointer //////////////////////////////////////////////////////////////////////////////// void TRI_DestroyVector(TRI_vector_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns length of vector //////////////////////////////////////////////////////////////////////////////// static inline size_t TRI_LengthVector(TRI_vector_t const* vector) { return static_cast(vector->_lengthX); } //////////////////////////////////////////////////////////////////////////////// /// @brief returns capacity of vector //////////////////////////////////////////////////////////////////////////////// static inline size_t TRI_CapacityVector(TRI_vector_t const* vector) { return static_cast(vector->_capacityX); } //////////////////////////////////////////////////////////////////////////////// /// @brief ensures a vector has space for extraCapacity more items //////////////////////////////////////////////////////////////////////////////// int TRI_ReserveVector(TRI_vector_t*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief adjusts the length of the vector //////////////////////////////////////////////////////////////////////////////// void TRI_SetLengthVector(TRI_vector_t*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief resizes the vector //////////////////////////////////////////////////////////////////////////////// int TRI_ResizeVector(TRI_vector_t*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief adds and element at the end //////////////////////////////////////////////////////////////////////////////// int TRI_PushBackVector(TRI_vector_t*, void const*); //////////////////////////////////////////////////////////////////////////////// /// @brief removes an element //////////////////////////////////////////////////////////////////////////////// void TRI_RemoveVector(TRI_vector_t*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief returns an element to the vector after borrowing it via /// TRI_NextVector. This will also decrease the vector length by one. /// The caller must ensure that the element has been fetched from the vector /// before. //////////////////////////////////////////////////////////////////////////////// void TRI_ReturnVector(TRI_vector_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief increases vector length by one and returns the address of the /// (uninitialized) element at the new position //////////////////////////////////////////////////////////////////////////////// void* TRI_NextVector(TRI_vector_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the element at a given position, no bounds checking //////////////////////////////////////////////////////////////////////////////// static inline void* TRI_AddressVector(TRI_vector_t const* vector, size_t pos) { return static_cast(vector->_buffer + pos * static_cast(vector->_elementSizeX)); } //////////////////////////////////////////////////////////////////////////////// /// @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 //////////////////////////////////////////////////////////////////////////////// int TRI_InsertVector(TRI_vector_t*, void const*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief sets an element at a given position //////////////////////////////////////////////////////////////////////////////// void TRI_SetVector(TRI_vector_t*, size_t, void const*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the beginning //////////////////////////////////////////////////////////////////////////////// void* TRI_BeginVector(TRI_vector_t const*); //////////////////////////////////////////////////////////////////////////////// /// @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; //////////////////////////////////////////////////////////////////////////////// /// @brief initializes a vector //////////////////////////////////////////////////////////////////////////////// void TRI_InitVectorPointer(TRI_vector_pointer_t*, TRI_memory_zone_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief initializes a vector, with user-definable settings //////////////////////////////////////////////////////////////////////////////// int TRI_InitVectorPointer(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 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 returns the element at a given position //////////////////////////////////////////////////////////////////////////////// void* TRI_AtVectorPointer(TRI_vector_pointer_t const*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @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; //////////////////////////////////////////////////////////////////////////////// /// @brief initializes a string vector //////////////////////////////////////////////////////////////////////////////// void TRI_InitVectorString(TRI_vector_string_t*, TRI_memory_zone_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*); //////////////////////////////////////////////////////////////////////////////// /// @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 removes an element, frees this element //////////////////////////////////////////////////////////////////////////////// void TRI_RemoveVectorString(TRI_vector_string_t*, size_t n); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the element at a given position //////////////////////////////////////////////////////////////////////////////// char* TRI_AtVectorString(TRI_vector_string_t const*, size_t); #endif