mirror of https://gitee.com/bigwinds/arangodb
697 lines
24 KiB
C++
697 lines
24 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief associative multi array implementation
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 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
|
|
/// @author Martin Schoenert
|
|
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
|
|
/// @author Copyright 2006-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "associative-multi.h"
|
|
#include "Basics/prime-numbers.h"
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- ASSOCIATIVE POINTERS
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private defines
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initial number of elements of a container
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define INITIAL_SIZE (64)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief forward declaration
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int ResizeMultiPointer (TRI_multi_pointer_t* array, size_t size);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialises an array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_InitMultiPointer (TRI_multi_pointer_t* array,
|
|
TRI_memory_zone_t* zone,
|
|
uint64_t (*hashKey) (TRI_multi_pointer_t*,
|
|
void const*),
|
|
uint64_t (*hashElement) (TRI_multi_pointer_t*,
|
|
void const*, bool),
|
|
bool (*isEqualKeyElement) (TRI_multi_pointer_t*,
|
|
void const*, void const*),
|
|
bool (*isEqualElementElement) (TRI_multi_pointer_t*,
|
|
void const*,
|
|
void const*, bool)) {
|
|
array->hashKey = hashKey;
|
|
array->hashElement = hashElement;
|
|
array->isEqualKeyElement = isEqualKeyElement;
|
|
array->isEqualElementElement = isEqualElementElement;
|
|
|
|
array->_memoryZone = zone;
|
|
array->_nrUsed = 0;
|
|
array->_nrAlloc = 0;
|
|
|
|
if (nullptr == (array->_table_alloc = static_cast<TRI_multi_pointer_entry_t*>(TRI_Allocate(zone,
|
|
sizeof(TRI_multi_pointer_entry_t) * INITIAL_SIZE + 64, true)))) {
|
|
return TRI_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
array->_table = (TRI_multi_pointer_entry_t*) TRI_Align64(array->_table_alloc);
|
|
|
|
array->_nrAlloc = INITIAL_SIZE;
|
|
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrFinds = 0;
|
|
array->_nrAdds = 0;
|
|
array->_nrRems = 0;
|
|
array->_nrResizes = 0;
|
|
array->_nrProbes = 0;
|
|
array->_nrProbesF = 0;
|
|
array->_nrProbesD = 0;
|
|
#endif
|
|
|
|
return TRI_ERROR_NO_ERROR;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys an array, but does not free the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_DestroyMultiPointer (TRI_multi_pointer_t* array) {
|
|
if (array->_table != nullptr) {
|
|
TRI_Free(array->_memoryZone, array->_table_alloc);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destroys an array and frees the pointer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TRI_FreeMultiPointer (TRI_memory_zone_t* zone, TRI_multi_pointer_t* array) {
|
|
TRI_DestroyMultiPointer(array);
|
|
TRI_Free(zone, array);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#if 0
|
|
// Activate for additional debugging:
|
|
#define TRI_CHECK_MULTI_POINTER_HASH 1
|
|
#endif
|
|
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
bool TRI_CheckMultiPointerHash (TRI_multi_pointer_t* array, bool checkCount,
|
|
bool checkPositions) {
|
|
uint64_t i, ii, j, k;
|
|
|
|
bool ok = true;
|
|
uint64_t count = 0;
|
|
|
|
for (i = 0;i < array->_nrAlloc;i++) {
|
|
if (array->_table[i].ptr != nullptr) {
|
|
count++;
|
|
if (array->_table[i].prev != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
if (array->_table[array->_table[i].prev].next != i) {
|
|
printf("Alarm prev %llu\n",(unsigned long long) i);
|
|
ok = false;
|
|
}
|
|
}
|
|
if (array->_table[i].next != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
if (array->_table[array->_table[i].next].prev != i) {
|
|
printf("Alarm next %llu\n",(unsigned long long) i);
|
|
ok = false;
|
|
}
|
|
}
|
|
ii = i;
|
|
j = array->_table[ii].next;
|
|
while (j != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
if (j == i) {
|
|
printf("Alarm cycle %llu\n",(unsigned long long) i);
|
|
ok = false;
|
|
break;
|
|
}
|
|
ii = j;
|
|
j = array->_table[ii].next;
|
|
}
|
|
}
|
|
}
|
|
if (checkCount && count != array->_nrUsed) {
|
|
printf("Alarm nrUsed wrong %llu != %llu!\n",
|
|
(unsigned long long) array->_nrUsed,
|
|
(unsigned long long) count);
|
|
ok = false;
|
|
}
|
|
if (checkPositions) {
|
|
for (i = 0;i < array->_nrAlloc;i++) {
|
|
if (array->_table[i].ptr != nullptr) {
|
|
uint64_t hash;
|
|
if (array->_table[i].prev == TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
// We are the first in a linked list.
|
|
hash = array->hashElement(array, array->_table[i].ptr,true);
|
|
j = hash % array->_nrAlloc;
|
|
for (k = j; k != i; ) {
|
|
if (array->_table[k].ptr == nullptr ||
|
|
(array->_table[k].prev == TRI_MULTI_POINTER_INVALID_INDEX &&
|
|
array->isEqualElementElement(array, array->_table[i].ptr,
|
|
array->_table[k].ptr,
|
|
true))) {
|
|
ok = false;
|
|
printf("Alarm pos bykey: %llu\n", (unsigned long long) i);
|
|
}
|
|
k = TRI_IncModU64(k, array->_nrAlloc);
|
|
}
|
|
}
|
|
else {
|
|
// We are not the first in a linked list.
|
|
hash = array->hashElement(array, array->_table[i].ptr, false);
|
|
j = hash % array->_nrAlloc;
|
|
for (k = j; k != i; ) {
|
|
if (array->_table[k].ptr == nullptr ||
|
|
array->isEqualElementElement(array, array->_table[i].ptr,
|
|
array->_table[k].ptr, false)) {
|
|
ok = false;
|
|
printf("Alarm unique: %llu, %llu\n", (unsigned long long) k,
|
|
(unsigned long long) i);
|
|
}
|
|
k = TRI_IncModU64(k, array->_nrAlloc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (! ok) {
|
|
printf("Something is wrong!");
|
|
}
|
|
return ok;
|
|
}
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief find an element or its place using the element hash function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static inline uint64_t FindElementPlace (TRI_multi_pointer_t* array,
|
|
void const* element,
|
|
bool checkEquality) {
|
|
// This either finds a place to store element or an entry in the table
|
|
// that is equal to element. If checkEquality is set to false, the caller
|
|
// guarantees that there is no entry that compares equal to element
|
|
// in the table, which saves a lot of element comparisons. This function
|
|
// always returns a pointer into the table, which is either empty or
|
|
// points to an entry that compares equal to element.
|
|
|
|
uint64_t hash;
|
|
uint64_t i;
|
|
|
|
hash = array->hashElement(array, element, false);
|
|
i = hash % array->_nrAlloc;
|
|
|
|
while (array->_table[i].ptr != nullptr &&
|
|
(! checkEquality ||
|
|
! array->isEqualElementElement(array, element,
|
|
array->_table[i].ptr, false))) {
|
|
i = TRI_IncModU64(i, array->_nrAlloc);
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrProbes++;
|
|
#endif
|
|
}
|
|
return i;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief find an element or its place by key or element identity
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static uint64_t LookupByElement (TRI_multi_pointer_t* array,
|
|
void const* element) {
|
|
// This performs a complete lookup for an element. It returns a slot
|
|
// number. This slot is either empty or contains an element that
|
|
// compares equal to element.
|
|
uint64_t hash;
|
|
uint64_t i;
|
|
|
|
// compute the hash
|
|
hash = array->hashElement(array, element, true);
|
|
i = hash % array->_nrAlloc;
|
|
|
|
// Now find the first slot with an entry with the same key that is the
|
|
// start of a linked list, or a free slot:
|
|
while (array->_table[i].ptr != nullptr &&
|
|
(array->_table[i].prev != TRI_MULTI_POINTER_INVALID_INDEX ||
|
|
! array->isEqualElementElement(array, element,
|
|
array->_table[i].ptr, true))) {
|
|
i = TRI_IncModU64(i, array->_nrAlloc);
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrProbes++;
|
|
#endif
|
|
}
|
|
|
|
if (array->_table[i].ptr != nullptr) {
|
|
// It might be right here!
|
|
if (array->isEqualElementElement(array, element,
|
|
array->_table[i].ptr, false)) {
|
|
return i;
|
|
}
|
|
|
|
// Now we have to look for it in its hash position:
|
|
uint64_t j = FindElementPlace(array, element, true);
|
|
|
|
// We have either found an equal element or nothing:
|
|
return j;
|
|
}
|
|
|
|
// If we get here, no element with the same key is in the array, so
|
|
// we will not be able to find it anywhere!
|
|
return i;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief helper to decide whether something is between to places
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static inline bool IsBetween (uint64_t from, uint64_t x, uint64_t to) {
|
|
// returns whether or not x is behind from and before or equal to
|
|
// to in the cyclic order. If x is equal to from, then the result is
|
|
// always false. If from is equal to to, then the result is always
|
|
// true.
|
|
return (from < to) ? (from < x && x <= to)
|
|
: (x > from || x <= to);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief helper to invalidate a slot
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static inline void InvalidateEntry (TRI_multi_pointer_t* array, uint64_t i) {
|
|
array->_table[i].ptr = nullptr;
|
|
array->_table[i].next = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
array->_table[i].prev = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief helper to move an entry from one slot to another
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static inline void MoveEntry (TRI_multi_pointer_t* array,
|
|
uint64_t from, uint64_t to) {
|
|
// Moves an entry, adjusts the linked lists, but does not take care
|
|
// for the hole. to must be unused. from can be any element in a
|
|
// linked list.
|
|
array->_table[to] = array->_table[from];
|
|
if (array->_table[to].prev != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
array->_table[array->_table[to].prev].next = to;
|
|
}
|
|
if (array->_table[to].next != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
array->_table[array->_table[to].next].prev = to;
|
|
}
|
|
InvalidateEntry(array, from);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief helper to heal a hole where we deleted something
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void HealHole (TRI_multi_pointer_t* array, uint64_t i) {
|
|
uint64_t j = TRI_IncModU64(i, array->_nrAlloc);
|
|
|
|
while (array->_table[j].ptr != nullptr) {
|
|
// Find out where this element ought to be:
|
|
// If it is the start of one of the linked lists, we need to hash
|
|
// by key, otherwise, we hash by the full identity of the element:
|
|
uint64_t hash = array->hashElement(array, array->_table[j].ptr,
|
|
array->_table[j].prev == TRI_MULTI_POINTER_INVALID_INDEX);
|
|
uint64_t k = hash % array->_nrAlloc;
|
|
if (! IsBetween(i, k, j)) {
|
|
// we have to move j to i:
|
|
MoveEntry(array, j, i);
|
|
i = j; // Now heal this hole at j, j will be incremented right away
|
|
}
|
|
j = TRI_IncModU64(j, array->_nrAlloc);
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrProbesD++;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the memory used by the index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
size_t TRI_MemoryUsageMultiPointer (TRI_multi_pointer_t const* array) {
|
|
return (size_t) array->_nrAlloc * sizeof(TRI_multi_pointer_entry_t) + 64;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds a key/element to the array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_InsertElementMultiPointer (TRI_multi_pointer_t* array,
|
|
void* element,
|
|
bool const overwrite,
|
|
bool const checkEquality) {
|
|
|
|
// if the checkEquality flag is not set, we do not check for element
|
|
// equality we use this flag to speed up initial insertion into the
|
|
// index, i.e. when the index is built for a collection and we know
|
|
// for sure no duplicate elements will be inserted
|
|
|
|
uint64_t hash;
|
|
uint64_t i, j;
|
|
void* old;
|
|
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
|
|
// if we were adding and the table is more than half full, extend it
|
|
if (array->_nrAlloc < 2 * array->_nrUsed) {
|
|
ResizeMultiPointer(array, (size_t) (2 * array->_nrAlloc + 1));
|
|
}
|
|
|
|
#ifdef TRI_INTERNAL_STATS
|
|
// update statistics
|
|
array->_nrAdds++;
|
|
#endif
|
|
|
|
// compute the hash by the key only first
|
|
hash = array->hashElement(array, element, true);
|
|
i = hash % array->_nrAlloc;
|
|
|
|
// If this slot is free, just use it:
|
|
if (nullptr == array->_table[i].ptr) {
|
|
array->_table[i].ptr = element;
|
|
array->_table[i].next = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
array->_table[i].prev = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
array->_nrUsed++;
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
// Now find the first slot with an entry with the same key that is the
|
|
// start of a linked list, or a free slot:
|
|
while (array->_table[i].ptr != nullptr &&
|
|
(! array->isEqualElementElement(array, element,
|
|
array->_table[i].ptr,true) ||
|
|
array->_table[i].prev != TRI_MULTI_POINTER_INVALID_INDEX)) {
|
|
i = TRI_IncModU64(i, array->_nrAlloc);
|
|
#ifdef TRI_INTERNAL_STATS
|
|
// update statistics
|
|
array->_ProbesA++;
|
|
#endif
|
|
|
|
}
|
|
|
|
// If this is free, we are the first with this key:
|
|
if (nullptr == array->_table[i].ptr) {
|
|
array->_table[i].ptr = element;
|
|
array->_table[i].next = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
array->_table[i].prev = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
array->_nrUsed++;
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
// Otherwise, entry i points to the beginning of the linked list of which
|
|
// we want to make element a member. Perhaps an equal element is right here:
|
|
if (checkEquality && array->isEqualElementElement(array, element,
|
|
array->_table[i].ptr,
|
|
false)) {
|
|
old = array->_table[i].ptr;
|
|
if (overwrite) {
|
|
array->_table[i].ptr = element;
|
|
}
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
return old;
|
|
}
|
|
|
|
// Now find a new home for element in this linked list:
|
|
j = FindElementPlace(array, element, checkEquality);
|
|
|
|
old = array->_table[j].ptr;
|
|
|
|
// if we found an element, return
|
|
if (old != nullptr) {
|
|
if (overwrite) {
|
|
array->_table[j].ptr = element;
|
|
}
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
return old;
|
|
}
|
|
|
|
// add a new element to the associative array and linked list (in pos 2):
|
|
array->_table[j].ptr = element;
|
|
array->_table[j].next = array->_table[i].next;
|
|
array->_table[j].prev = i;
|
|
array->_table[i].next = j;
|
|
// Finally, we need to find the successor to patch it up:
|
|
if (array->_table[j].next != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
array->_table[array->_table[j].next].prev = j;
|
|
}
|
|
array->_nrUsed++;
|
|
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookups an element given a key
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRI_vector_pointer_t TRI_LookupByKeyMultiPointer (TRI_memory_zone_t* zone,
|
|
TRI_multi_pointer_t* array,
|
|
void const* key) {
|
|
TRI_vector_pointer_t result;
|
|
uint64_t hash;
|
|
uint64_t i;
|
|
|
|
// initialises the result vector
|
|
TRI_InitVectorPointer(&result, zone);
|
|
|
|
// compute the hash
|
|
hash = array->hashKey(array, key);
|
|
i = hash % array->_nrAlloc;
|
|
|
|
#ifdef TRI_INTERNAL_STATS
|
|
// update statistics
|
|
array->_nrFinds++;
|
|
#endif
|
|
|
|
// search the table
|
|
while (array->_table[i].ptr != nullptr &&
|
|
(! array->isEqualKeyElement(array, key, array->_table[i].ptr) ||
|
|
array->_table[i].prev != TRI_MULTI_POINTER_INVALID_INDEX)) {
|
|
i = TRI_IncModU64(i, array->_nrAlloc);
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrProbesF++;
|
|
#endif
|
|
}
|
|
|
|
if (array->_table[i].ptr != nullptr) {
|
|
// We found the beginning of the linked list:
|
|
|
|
// pre-initialize the result to save at least a few reallocs
|
|
TRI_InitVectorPointer2(&result, zone, 4);
|
|
do {
|
|
TRI_PushBackVectorPointer(&result, array->_table[i].ptr);
|
|
i = array->_table[i].next;
|
|
}
|
|
while (i != TRI_MULTI_POINTER_INVALID_INDEX);
|
|
}
|
|
|
|
// return whatever we found
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookups an element given an element
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_LookupByElementMultiPointer (TRI_multi_pointer_t* array,
|
|
void const* element) {
|
|
uint64_t i;
|
|
|
|
#ifdef TRI_INTERNAL_STATS
|
|
// update statistics
|
|
array->_nrFinds++;
|
|
#endif
|
|
|
|
i = LookupByElement(array, element);
|
|
return array->_table[i].ptr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element from the array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void* TRI_RemoveElementMultiPointer (TRI_multi_pointer_t* array, void const* element) {
|
|
uint64_t i, j;
|
|
void* old;
|
|
|
|
#ifdef TRI_INTERNAL_STATS
|
|
// update statistics
|
|
array->_nrRems++;
|
|
#endif
|
|
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
i = LookupByElement(array, element);
|
|
if (array->_table[i].ptr == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
old = array->_table[i].ptr;
|
|
// We have to delete entry i
|
|
if (array->_table[i].prev == TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
// This is the first in its linked list.
|
|
j = array->_table[i].next;
|
|
if (j == TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
// The only one in its linked list, simply remove it and heal
|
|
// the hole:
|
|
InvalidateEntry(array, i);
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, false, false);
|
|
#endif
|
|
HealHole(array, i);
|
|
}
|
|
else {
|
|
// There is at least one successor in position j.
|
|
array->_table[j].prev = TRI_MULTI_POINTER_INVALID_INDEX;
|
|
MoveEntry(array, j, i);
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, false, false);
|
|
#endif
|
|
HealHole(array, j);
|
|
}
|
|
}
|
|
else {
|
|
// This one is not the first in its linked list
|
|
j = array->_table[i].prev;
|
|
array->_table[j].next = array->_table[i].next;
|
|
j = array->_table[i].next;
|
|
if (j != TRI_MULTI_POINTER_INVALID_INDEX) {
|
|
// We are not the last in the linked list.
|
|
array->_table[j].prev = array->_table[i].prev;
|
|
}
|
|
InvalidateEntry(array, i);
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, false, false);
|
|
#endif
|
|
HealHole(array, i);
|
|
}
|
|
array->_nrUsed--;
|
|
#ifdef TRI_CHECK_MULTI_POINTER_HASH
|
|
TRI_CheckMultiPointerHash(array, true, true);
|
|
#endif
|
|
// return success
|
|
return old;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resize the array, internal version taking the size as given
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int ResizeMultiPointer (TRI_multi_pointer_t* array, size_t size) {
|
|
TRI_multi_pointer_entry_t* oldTable_alloc;
|
|
TRI_multi_pointer_entry_t* oldTable;
|
|
uint64_t oldAlloc;
|
|
uint64_t j;
|
|
|
|
oldTable_alloc = array->_table_alloc;
|
|
oldTable = array->_table;
|
|
oldAlloc = array->_nrAlloc;
|
|
|
|
array->_nrAlloc = TRI_NearPrime((uint64_t) size);
|
|
array->_table_alloc = static_cast<TRI_multi_pointer_entry_t*>(TRI_Allocate(array->_memoryZone,
|
|
array->_nrAlloc * sizeof(TRI_multi_pointer_entry_t) + 64, true));
|
|
array->_table = (TRI_multi_pointer_entry_t*) TRI_Align64(array->_table_alloc);
|
|
|
|
if (array->_table == nullptr) {
|
|
array->_nrAlloc = oldAlloc;
|
|
array->_table = oldTable;
|
|
array->_table_alloc = oldTable_alloc;
|
|
|
|
return TRI_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
array->_nrUsed = 0;
|
|
#ifdef TRI_INTERNAL_STATS
|
|
array->_nrResizes++;
|
|
#endif
|
|
|
|
// table is already clear by allocate, copy old data
|
|
for (j = 0; j < oldAlloc; j++) {
|
|
if (oldTable[j].ptr != nullptr) {
|
|
TRI_InsertElementMultiPointer(array, oldTable[j].ptr, true, false);
|
|
}
|
|
}
|
|
|
|
TRI_Free(array->_memoryZone, oldTable_alloc);
|
|
|
|
return TRI_ERROR_NO_ERROR;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resize the array, adds a reserve of a factor of 2
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_ResizeMultiPointer (TRI_multi_pointer_t* array, size_t size) {
|
|
if (2*size+1 < array->_nrUsed) {
|
|
return TRI_ERROR_BAD_PARAMETER;
|
|
}
|
|
|
|
return ResizeMultiPointer(array, 2*size+1);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
|
|
// End:
|