mirror of https://gitee.com/bigwinds/arangodb
632 lines
20 KiB
C++
632 lines
20 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief datafiles
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2004-2013 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-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "headers.h"
|
|
|
|
#include "BasicsC/logging.h"
|
|
#include "VocBase/primary-collection.h"
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private defines
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup VocBase
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief minium number of headers per block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define BLOCK_SIZE_UNIT (128)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private types
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct simple_headers_s {
|
|
TRI_headers_t base;
|
|
|
|
TRI_doc_mptr_t const* _freelist; // free headers
|
|
|
|
TRI_doc_mptr_t* _begin; // start pointer to list of allocated headers
|
|
TRI_doc_mptr_t* _end; // end pointer to list of allocated headers
|
|
size_t _nrAllocated; // number of allocated headers
|
|
size_t _nrLinked; // number of linked headers
|
|
int64_t _totalSize; // total size of markers for linked headers
|
|
|
|
TRI_vector_pointer_t _blocks;
|
|
}
|
|
simple_headers_t;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the size (number of entries) for a block, based on a function
|
|
///
|
|
/// this adaptively increases the number of entries per block until a certain
|
|
/// threshold. the benefit of this is that small collections (with few
|
|
/// documents) only use little memory whereas bigger collections allocate new
|
|
/// blocks in bigger chunks.
|
|
/// the lowest value for the number of entries in a block is BLOCK_SIZE_UNIT,
|
|
/// the highest value is BLOCK_SIZE_UNIT << 8.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static size_t GetBlockSize (const size_t blockNumber) {
|
|
if (blockNumber < 8) {
|
|
return (size_t) (BLOCK_SIZE_UNIT << blockNumber);
|
|
}
|
|
|
|
return (size_t) (BLOCK_SIZE_UNIT << 8);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clears a header
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void ClearHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
TRI_ASSERT_MAINTAINER(header != NULL);
|
|
|
|
memset(header, 0, sizeof(TRI_doc_mptr_t));
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_nrAllocated > 0);
|
|
headers->_nrAllocated--;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief moves an existing header to the end of the list
|
|
/// this is called when there is an update operation on a document
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void MoveBackHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header,
|
|
TRI_doc_mptr_t* old) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
int64_t oldSize;
|
|
int64_t newSize;
|
|
|
|
if (header == NULL) {
|
|
return;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_nrAllocated > 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_nrLinked > 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize > 0);
|
|
|
|
// we have at least one element in the list
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != NULL);
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
|
|
TRI_ASSERT_MAINTAINER(old != NULL);
|
|
TRI_ASSERT_MAINTAINER(old->_data != NULL);
|
|
|
|
newSize = (int64_t) (((TRI_df_marker_t*) header->_data)->_size);
|
|
oldSize = (int64_t) (((TRI_df_marker_t*) old->_data)->_size);
|
|
|
|
// we must adjust the size of the collection
|
|
headers->_totalSize += TRI_DF_ALIGN_BLOCK(newSize);
|
|
headers->_totalSize -= TRI_DF_ALIGN_BLOCK(oldSize);
|
|
|
|
if (headers->_end == header) {
|
|
// header is already at the end
|
|
TRI_ASSERT_MAINTAINER(header->_next == NULL);
|
|
return;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != headers->_end);
|
|
|
|
// unlink the element
|
|
if (header->_prev != NULL) {
|
|
header->_prev->_next = header->_next;
|
|
}
|
|
if (header->_next != NULL) {
|
|
header->_next->_prev = header->_prev;
|
|
}
|
|
|
|
if (headers->_begin == header) {
|
|
TRI_ASSERT_MAINTAINER(header->_next != NULL);
|
|
headers->_begin = header->_next;
|
|
}
|
|
|
|
header->_prev = headers->_end;
|
|
header->_next = NULL;
|
|
headers->_end = header;
|
|
header->_prev->_next = header;
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != NULL);
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize > 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief unlinks a header from the list, without freeing it
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void UnlinkHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
int64_t size;
|
|
|
|
TRI_ASSERT_MAINTAINER(header != NULL);
|
|
TRI_ASSERT_MAINTAINER(header->_data != NULL);
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
|
|
size = (int64_t) ((TRI_df_marker_t*) header->_data)->_size;
|
|
TRI_ASSERT_MAINTAINER(size > 0);
|
|
|
|
// unlink the header
|
|
if (header->_prev != NULL) {
|
|
header->_prev->_next = header->_next;
|
|
}
|
|
|
|
if (header->_next != NULL) {
|
|
header->_next->_prev = header->_prev;
|
|
}
|
|
|
|
// adjust begin & end pointers
|
|
if (headers->_begin == header) {
|
|
headers->_begin = header->_next;
|
|
}
|
|
|
|
if (headers->_end == header) {
|
|
headers->_end = header->_prev;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != header);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != header);
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_nrLinked > 0);
|
|
headers->_nrLinked--;
|
|
headers->_totalSize -= TRI_DF_ALIGN_BLOCK(size);
|
|
|
|
if (headers->_nrLinked == 0) {
|
|
TRI_ASSERT_MAINTAINER(headers->_begin == NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end == NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize == 0);
|
|
}
|
|
else {
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize > 0);
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief moves a header around in the list, using its previous position
|
|
/// (specified in "old")
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void MoveHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header,
|
|
TRI_doc_mptr_t* old) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
int64_t newSize;
|
|
int64_t oldSize;
|
|
|
|
if (header == NULL) {
|
|
return;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_nrAllocated > 0);
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
TRI_ASSERT_MAINTAINER(header->_data != NULL);
|
|
TRI_ASSERT_MAINTAINER(((TRI_df_marker_t*) header->_data)->_size > 0);
|
|
TRI_ASSERT_MAINTAINER(old != NULL);
|
|
TRI_ASSERT_MAINTAINER(old->_data != NULL);
|
|
|
|
newSize = (int64_t) (((TRI_df_marker_t*) header->_data)->_size);
|
|
oldSize = (int64_t) (((TRI_df_marker_t*) old->_data)->_size);
|
|
|
|
headers->_totalSize -= TRI_DF_ALIGN_BLOCK(newSize);
|
|
headers->_totalSize += TRI_DF_ALIGN_BLOCK(oldSize);
|
|
|
|
// adjust list start and end pointers
|
|
if (old->_prev == NULL) {
|
|
headers->_begin = header;
|
|
}
|
|
else if (headers->_begin == header) {
|
|
headers->_begin = header->_next;
|
|
}
|
|
|
|
if (old->_next == NULL) {
|
|
headers->_end = header;
|
|
}
|
|
else if (headers->_end == header) {
|
|
headers->_end = header->_prev;
|
|
}
|
|
|
|
if (header->_prev != NULL) {
|
|
if (header->_prev == old->_next) {
|
|
header->_prev->_next = NULL;
|
|
}
|
|
else {
|
|
header->_prev->_next = header->_next;
|
|
}
|
|
}
|
|
|
|
if (header->_next != NULL) {
|
|
if (header->_next == old->_prev) {
|
|
header->_next->_prev = NULL;
|
|
}
|
|
else {
|
|
header->_next->_prev = header->_prev;
|
|
}
|
|
}
|
|
|
|
if (old->_prev != NULL) {
|
|
old->_prev->_next = header;
|
|
header->_prev = old->_prev;
|
|
}
|
|
else {
|
|
header->_prev = NULL;
|
|
}
|
|
|
|
if (old->_next != NULL) {
|
|
old->_next->_prev = header;
|
|
header->_next = old->_next;
|
|
}
|
|
else {
|
|
header->_next = NULL;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != NULL);
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief moves a header back into the list, using its previous position
|
|
/// (specified in "old")
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void RelinkHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header,
|
|
TRI_doc_mptr_t* old) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
int64_t size;
|
|
|
|
if (header == NULL) {
|
|
return;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(header->_data != NULL);
|
|
|
|
size = (int64_t) ((TRI_df_marker_t*) header->_data)->_size;
|
|
TRI_ASSERT_MAINTAINER(size > 0);
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != header);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != header);
|
|
|
|
MoveHeader(h, header, old);
|
|
headers->_nrLinked++;
|
|
headers->_totalSize += TRI_DF_ALIGN_BLOCK(size);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize > 0);
|
|
|
|
TRI_ASSERT_MAINTAINER(header->_prev != header);
|
|
TRI_ASSERT_MAINTAINER(header->_next != header);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief requests a new header
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static TRI_doc_mptr_t* RequestHeader (TRI_headers_t* h,
|
|
size_t size) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
char const* header;
|
|
|
|
assert(size > 0);
|
|
|
|
if (headers->_freelist == NULL) {
|
|
size_t blockSize = GetBlockSize(headers->_blocks._length);
|
|
TRI_ASSERT_MAINTAINER(blockSize > 0);
|
|
|
|
// initialise the memory with 0's
|
|
char* begin = static_cast<char*>(TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, blockSize * sizeof(TRI_doc_mptr_t), true));
|
|
|
|
// out of memory
|
|
if (begin == NULL) {
|
|
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
char* ptr = begin + sizeof(TRI_doc_mptr_t) * (blockSize - 1);
|
|
|
|
header = NULL;
|
|
|
|
for (; begin <= ptr; ptr -= sizeof(TRI_doc_mptr_t)) {
|
|
((TRI_doc_mptr_t*) ptr)->_data = header;
|
|
header = ptr;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers != NULL);
|
|
headers->_freelist = (TRI_doc_mptr_t*) header;
|
|
|
|
TRI_PushBackVectorPointer(&headers->_blocks, begin);
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(headers->_freelist != NULL);
|
|
|
|
TRI_doc_mptr_t* result = const_cast<TRI_doc_mptr_t*>(headers->_freelist);
|
|
TRI_ASSERT_MAINTAINER(result != NULL);
|
|
|
|
headers->_freelist = static_cast<TRI_doc_mptr_t const*>(result->_data);
|
|
result->_data = NULL;
|
|
|
|
// put new header at the end of the list
|
|
if (headers->_begin == NULL) {
|
|
// list of headers is empty
|
|
TRI_ASSERT_MAINTAINER(headers->_nrLinked == 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize == 0);
|
|
|
|
headers->_begin = result;
|
|
headers->_end = result;
|
|
|
|
result->_prev = NULL;
|
|
result->_next = NULL;
|
|
}
|
|
else {
|
|
// list is not empty
|
|
TRI_ASSERT_MAINTAINER(headers->_nrLinked > 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_totalSize > 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_nrAllocated > 0);
|
|
TRI_ASSERT_MAINTAINER(headers->_begin != NULL);
|
|
TRI_ASSERT_MAINTAINER(headers->_end != NULL);
|
|
|
|
headers->_end->_next = result;
|
|
result->_prev = headers->_end;
|
|
result->_next = NULL;
|
|
headers->_end = result;
|
|
}
|
|
|
|
headers->_nrAllocated++;
|
|
headers->_nrLinked++;
|
|
headers->_totalSize += (int64_t) TRI_DF_ALIGN_BLOCK(size);
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief releases a header, putting it back onto the freelist
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void ReleaseHeader (TRI_headers_t* h,
|
|
TRI_doc_mptr_t* header,
|
|
bool unlinkHeader) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
if (header == NULL) {
|
|
return;
|
|
}
|
|
|
|
if (unlinkHeader) {
|
|
UnlinkHeader(h, header);
|
|
}
|
|
|
|
ClearHeader(h, header);
|
|
|
|
header->_data = headers->_freelist;
|
|
headers->_freelist = header;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the element at the head of the list
|
|
///
|
|
/// note: the element returned might be NULL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static TRI_doc_mptr_t* FrontHeaders (TRI_headers_t const* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
return headers->_begin;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the element at the tail of the list
|
|
///
|
|
/// note: the element returned might be NULL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static TRI_doc_mptr_t* BackHeaders (TRI_headers_t const* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
return headers->_end;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the number of linked headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static size_t CountHeaders (TRI_headers_t const* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
return headers->_nrLinked;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the total size of linked headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int64_t TotalSizeHeaders (TRI_headers_t const* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
|
|
return (int64_t) headers->_totalSize;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief dump all headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef TRI_ENABLE_MAINTAINER_MODE
|
|
|
|
static void DumpHeaders (TRI_headers_t const* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
TRI_doc_mptr_t* next = headers->_begin;
|
|
size_t i = 0;
|
|
|
|
printf("number of allocated headers: %lu\n", (unsigned long) headers->_nrAllocated);
|
|
printf("number of linked headers: %lu\n", (unsigned long) headers->_nrLinked);
|
|
printf("total size: %lld\n", (long long) headers->_totalSize);
|
|
|
|
printf("begin ptr: %p\n", headers->_begin);
|
|
printf("end ptr: %p\n", headers->_end);
|
|
|
|
while (next != NULL) {
|
|
printf("- header #%lu: ptr: %p, prev: %p, next: %p, key: %s\n",
|
|
(unsigned long) i,
|
|
next,
|
|
next->_prev,
|
|
next->_next,
|
|
next->_key);
|
|
i++;
|
|
|
|
if (next->_next == NULL) {
|
|
TRI_ASSERT_MAINTAINER(next == headers->_end);
|
|
}
|
|
|
|
next = next->_next;
|
|
}
|
|
|
|
TRI_ASSERT_MAINTAINER(i == headers->_nrLinked);
|
|
}
|
|
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup VocBase
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief creates a new simple headers structures
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRI_headers_t* TRI_CreateSimpleHeaders () {
|
|
simple_headers_t* headers = static_cast<simple_headers_t*>(TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(simple_headers_t), false));
|
|
|
|
if (headers == NULL) {
|
|
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
headers->_freelist = NULL;
|
|
|
|
headers->_begin = NULL;
|
|
headers->_end = NULL;
|
|
headers->_nrAllocated = 0;
|
|
headers->_nrLinked = 0;
|
|
headers->_totalSize = 0;
|
|
|
|
headers->base.request = RequestHeader;
|
|
headers->base.release = ReleaseHeader;
|
|
headers->base.moveBack = MoveBackHeader;
|
|
headers->base.move = MoveHeader;
|
|
headers->base.relink = RelinkHeader;
|
|
headers->base.unlink = UnlinkHeader;
|
|
headers->base.front = FrontHeaders;
|
|
headers->base.back = BackHeaders;
|
|
headers->base.count = CountHeaders;
|
|
headers->base.size = TotalSizeHeaders;
|
|
#ifdef TRI_ENABLE_MAINTAINER_MODE
|
|
headers->base.dump = DumpHeaders;
|
|
#endif
|
|
|
|
TRI_InitVectorPointer2(&headers->_blocks, TRI_UNKNOWN_MEM_ZONE, 8);
|
|
|
|
return &headers->base;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a simple headers structures, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_DestroySimpleHeaders (TRI_headers_t* h) {
|
|
simple_headers_t* headers = (simple_headers_t*) h;
|
|
size_t i;
|
|
|
|
for (i = 0; i < headers->_blocks._length; ++i) {
|
|
TRI_Free(TRI_UNKNOWN_MEM_ZONE, headers->_blocks._buffer[i]);
|
|
}
|
|
|
|
headers->_nrAllocated = 0;
|
|
headers->_nrLinked = 0;
|
|
headers->_totalSize = 0;
|
|
|
|
TRI_DestroyVectorPointer(&headers->_blocks);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys a simple headers structures, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeSimpleHeaders (TRI_headers_t* headers) {
|
|
TRI_DestroySimpleHeaders(headers);
|
|
TRI_Free(TRI_UNKNOWN_MEM_ZONE, headers);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|/// @page\\|// --SECTION--\\|/// @\\}"
|
|
// End:
|