void TRI_InsertVector (TRI_vector_t* vector, void const* element, size_t position) {
char* newBuffer;
// ...........................................................................
// Check and see if we need to extend the vector
// ...........................................................................
if (vector->_length >= vector->_capacity || position >= vector->_length) {
size_t newSize = (size_t) (1 + (GROW_FACTOR * vector->_capacity));
if (position >= newSize) {
newSize = position + 1;
}
newBuffer = (char*) TRI_Allocate(vector->_memoryZone, newSize * vector->_elementSize, false);
if (newBuffer == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return;
}
vector->_capacity = newSize;
if (vector->_buffer != NULL) {
memcpy(newBuffer, vector->_buffer, vector->_length * vector->_elementSize);
TRI_Free(vector->_memoryZone, vector->_buffer);
}
vector->_buffer = newBuffer;
}
if (position < vector->_length) {
memmove(vector->_buffer + (vector->_elementSize * (position + 1)),
vector->_buffer + (vector->_elementSize * position),
vector->_elementSize * (vector->_length - position)
);
vector->_length += 1;
}
else {
vector->_length = position + 1;
}
memcpy(vector->_buffer + (vector->_elementSize * position), element, vector->_elementSize);
}
TRI_headers_t* TRI_CreateSimpleHeaders (size_t headerSize) {
simple_headers_t* headers = 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->base.request = RequestSimpleHeaders;
headers->base.verify = VerifySimpleHeaders;
headers->base.release = ReleaseSimpleHeaders;
headers->_freelist = NULL;
headers->_headerSize = headerSize;
TRI_InitVectorPointer(&headers->_blocks, TRI_UNKNOWN_MEM_ZONE);
return &headers->base;
}
int TRI_CopyToBlob (TRI_memory_zone_t* zone, TRI_blob_t* dst, TRI_blob_t const* src) {
dst->length = src->length;
if (src->length == 0 || src->data == nullptr) {
dst->length = 0;
dst->data = nullptr;
}
else {
dst->data = static_cast<char*>(TRI_Allocate(zone, dst->length, false));
if (dst->data == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
memcpy(dst->data, src->data, src->length);
}
return TRI_ERROR_NO_ERROR;
}
TRI_index_t* TRI_CreateGeo1Index (TRI_document_collection_t* document,
TRI_idx_iid_t iid,
char const* locationName,
TRI_shape_pid_t location,
bool geoJson,
bool unique,
bool ignoreNull) {
char* ln;
TRI_geo_index_t* geo = static_cast<TRI_geo_index_t*>(TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_geo_index_t), false));
TRI_index_t* idx = &geo->base;
TRI_InitVectorString(&idx->_fields, TRI_CORE_MEM_ZONE);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_GEO1_INDEX, document, unique, false);
idx->_ignoreNull = ignoreNull;
idx->memory = MemoryGeoIndex;
idx->json = JsonGeo1Index;
idx->insert = InsertGeoIndex;
idx->remove = RemoveGeoIndex;
ln = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, locationName);
TRI_PushBackVectorString(&idx->_fields, ln);
geo->_geoIndex = GeoIndex_new();
// oops, out of memory?
if (geo->_geoIndex == NULL) {
TRI_DestroyVectorString(&idx->_fields);
TRI_Free(TRI_CORE_MEM_ZONE, geo);
return NULL;
}
geo->_variant = geoJson ? INDEX_GEO_COMBINED_LAT_LON : INDEX_GEO_COMBINED_LON_LAT;
geo->_location = location;
geo->_latitude = 0;
geo->_longitude = 0;
geo->_geoJson = geoJson;
return idx;
}
static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
TRI_col_type_t type,
char const* name,
TRI_voc_cid_t cid,
char const* path) {
void const* found;
TRI_vocbase_col_t* col;
// create a new proxy
col = TRI_Allocate(sizeof(TRI_vocbase_col_t));
col->_vocbase = vocbase;
col->_type = type;
TRI_CopyString(col->_name, name, sizeof(col->_name));
col->_path = (path == NULL ? NULL : TRI_DuplicateString(path));
col->_collection = NULL;
col->_newBorn = 0;
col->_loaded = 0;
col->_corrupted = 0;
col->_cid = cid;
// check name
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsByName, name, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for name '%s'", name);
return NULL;
}
// check collection identifier
if (cid != 0) {
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsById, &cid, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for identifier '%s'", cid);
return NULL;
}
}
TRI_PushBackVectorPointer(&vocbase->_collections, col);
return col;
}
TRI_aql_for_hint_t* TRI_CreateForHintScopeAql (TRI_aql_context_t* const context) {
TRI_aql_for_hint_t* hint;
assert(context);
hint = (TRI_aql_for_hint_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_for_hint_t), false);
if (hint == NULL) {
TRI_SetErrorContextAql(__FILE__, __LINE__, context, TRI_ERROR_OUT_OF_MEMORY, NULL);
return NULL;
}
// initialise
hint->_limit._offset = 0;
hint->_limit._limit = 0;
hint->_limit._status = TRI_AQL_LIMIT_UNDEFINED;
hint->_isIncremental = false;
return hint;
}
TRI_json_t* TRI_CopyJson (TRI_memory_zone_t* zone, TRI_json_t* src) {
TRI_json_t* dst;
int res;
dst = (TRI_json_t*) TRI_Allocate(zone, sizeof(TRI_json_t), false);
if (dst == NULL) {
return NULL;
}
res = TRI_CopyToJson(zone, dst, src);
if (res != TRI_ERROR_NO_ERROR) {
TRI_Free(zone, dst);
return NULL;
}
return dst;
}
static int FillIndexSearchValueByHashIndexElement (TRI_hash_index_t* hashIndex,
TRI_index_search_value_t* key,
T* element) {
key->_values = static_cast<TRI_shaped_json_t*>(TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, KeyEntrySize(hashIndex), false));
if (key->_values == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
char const* ptr = element->_document->getShapedJsonPtr(); // ONLY IN INDEX
size_t const n = NumPaths(hashIndex);
for (size_t i = 0; i < n; ++i) {
key->_values[i]._sid = element->_subObjects[i]._sid;
key->_values[i]._data.length = element->_subObjects[i]._length;
key->_values[i]._data.data = const_cast<char*>(ptr + element->_subObjects[i]._offset);
}
return TRI_ERROR_NO_ERROR;
}
TRI_barrier_t* TRI_CreateBarrierElementZ (TRI_barrier_list_t* container,
size_t line,
char const* filename) {
TRI_barrier_blocker_t* element;
element = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_barrier_blocker_t), false);
if (element == NULL) {
return NULL;
}
element->base._type = TRI_BARRIER_ELEMENT;
element->_line = line;
element->_filename = filename;
LinkBarrierElement(&element->base, container);
return &element->base;
}
int TRI_CopyToBlob (TRI_memory_zone_t* zone, TRI_blob_t* dst, TRI_blob_t const* src) {
dst->length = src->length;
if (src->length == 0 || src->data == NULL) {
dst->length = 0;
dst->data = NULL;
}
else {
dst->length = src->length;
dst->data = TRI_Allocate(zone, dst->length, false);
if (dst->data == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
memcpy(dst->data, src->data, src->length);
}
return TRI_ERROR_NO_ERROR;
}
TRI_json_t* TRI_CreateString2CopyJson (TRI_memory_zone_t* zone, char const* value, size_t length) {
TRI_json_t* result;
result = (TRI_json_t*) TRI_Allocate(zone, sizeof(TRI_json_t), false);
if (result == NULL) {
return NULL;
}
result->_type = TRI_JSON_STRING;
result->_value._string.length = length + 1;
result->_value._string.data = TRI_DuplicateString2Z(zone, value, length);
if (result->_value._string.data == NULL) {
TRI_Free(zone, result);
return NULL;
}
return result;
}
static TRI_doc_mptr_t* RequestSimpleHeaders (TRI_headers_t* h) {
simple_headers_t* headers = (simple_headers_t*) h;
char const* header;
union { TRI_doc_mptr_t const* c; TRI_doc_mptr_t* h; } c;
if (headers->_freelist == NULL) {
char* begin;
char* ptr;
size_t blockSize;
blockSize = GetBlockSize(headers->_blocks._length);
begin = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, blockSize * headers->_headerSize, false);
// out of memory
if (begin == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return NULL;
}
ptr = begin + headers->_headerSize * (blockSize - 1);
header = NULL;
for (; begin <= ptr; ptr -= headers->_headerSize) {
ClearSimpleHeaders((TRI_doc_mptr_t*) ptr, headers->_headerSize);
((TRI_doc_mptr_t*) ptr)->_data = header;
header = ptr;
}
headers->_freelist = (TRI_doc_mptr_t*) header;
TRI_PushBackVectorPointer(&headers->_blocks, begin);
}
c.c = headers->_freelist;
headers->_freelist = c.c->_data;
c.h->_data = NULL;
return c.h;
}
TRI_json_t* TRI_CreateStringCopyJson (TRI_memory_zone_t* zone, char const* value, size_t length) {
if (value == nullptr) {
// initial string should be valid...
return nullptr;
}
TRI_json_t* result = static_cast<TRI_json_t*>(TRI_Allocate(zone, sizeof(TRI_json_t), false));
if (result != nullptr) {
char* copy = TRI_DuplicateString2Z(zone, value, length);
if (copy == nullptr) {
TRI_Free(zone, result);
return nullptr;
}
InitString(result, copy, length);
}
return result;
}
TRI_aql_collection_hint_t* TRI_CreateCollectionHintAql (void) {
TRI_aql_collection_hint_t* hint;
hint = (TRI_aql_collection_hint_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_collection_hint_t), false);
if (hint == NULL) {
return NULL;
}
hint->_ranges = NULL;
hint->_index = NULL;
hint->_collection = NULL;
hint->_variableName = NULL;
// init limit
hint->_limit._offset = 0;
hint->_limit._limit = INT64_MAX;
hint->_limit._status = TRI_AQL_LIMIT_UNDEFINED;
return hint;
}
bool TRI_RegisterMimetype (const char* extension,
const char* mimetype,
bool appendCharset) {
mimetype_t* entry;
void* found;
entry = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(mimetype_t), false);
entry->_extension = TRI_DuplicateString(extension);
entry->_appendCharset = appendCharset;
if (appendCharset) {
entry->_mimetype = TRI_Concatenate2String(mimetype, "; charset=utf-8");
}
else {
entry->_mimetype = TRI_DuplicateString(mimetype);
}
found = TRI_InsertKeyAssociativePointer(&Mimetypes, extension, entry, false);
return (found != NULL);
}
static TRI_aql_explain_t* CreateExplain (void) {
TRI_aql_explain_t* explain;
explain = (TRI_aql_explain_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_explain_t), false);
if (explain == NULL) {
return NULL;
}
explain->_count = 0;
explain->_level = 0;
explain->_result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (explain->_result == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, explain);
return NULL;
}
return explain;
}
int TRI_InitAssociativeArray (TRI_associative_array_t* array,
TRI_memory_zone_t* zone,
size_t elementSize,
uint64_t (*hashKey) (TRI_associative_array_t*, void*),
uint64_t (*hashElement) (TRI_associative_array_t*, void*),
void (*clearElement) (TRI_associative_array_t*, void*),
bool (*isEmptyElement) (TRI_associative_array_t*, void*),
bool (*isEqualKeyElement) (TRI_associative_array_t*, void*, void*),
bool (*isEqualElementElement) (TRI_associative_array_t*, void*, void*)) {
array->hashKey = hashKey;
array->hashElement = hashElement;
array->clearElement = clearElement;
array->isEmptyElement = isEmptyElement;
array->isEqualKeyElement = isEqualKeyElement;
array->isEqualElementElement = isEqualElementElement;
array->_memoryZone = zone;
array->_elementSize = (uint32_t) elementSize;
array->_nrAlloc = 0;
array->_nrUsed = 0;
if (NULL == (array->_table = static_cast<char*>(TRI_Allocate(zone, array->_elementSize * INITIAL_SIZE, true)))) {
return TRI_ERROR_OUT_OF_MEMORY;
}
array->_nrAlloc = INITIAL_SIZE;
#ifdef TRI_INTERNAL_STATS
array->_nrFinds = 0;
array->_nrAdds = 0;
array->_nrRems = 0;
array->_nrResizes = 0;
array->_nrProbesF = 0;
array->_nrProbesA = 0;
array->_nrProbesD = 0;
array->_nrProbesR = 0;
#endif
return TRI_ERROR_NO_ERROR;
}
void TRI_InitAssociativeArray (TRI_associative_array_t* array,
size_t elementSize,
uint64_t (*hashKey) (TRI_associative_array_t*, void*),
uint64_t (*hashElement) (TRI_associative_array_t*, void*),
void (*clearElement) (TRI_associative_array_t*, void*),
bool (*isEmptyElement) (TRI_associative_array_t*, void*),
bool (*isEqualKeyElement) (TRI_associative_array_t*, void*, void*),
bool (*isEqualElementElement) (TRI_associative_array_t*, void*, void*)) {
char* p;
char* e;
array->hashKey = hashKey;
array->hashElement = hashElement;
array->clearElement = clearElement;
array->isEmptyElement = isEmptyElement;
array->isEqualKeyElement = isEqualKeyElement;
array->isEqualElementElement = isEqualElementElement;
array->_elementSize = elementSize;
array->_nrAlloc = 10;
array->_table = TRI_Allocate(array->_elementSize * array->_nrAlloc);
p = array->_table;
e = p + array->_elementSize * array->_nrAlloc;
for (; p < e; p += array->_elementSize) {
array->clearElement(array, p);
}
array->_nrUsed = 0;
array->_nrFinds = 0;
array->_nrAdds = 0;
array->_nrRems = 0;
array->_nrResizes = 0;
array->_nrProbesF = 0;
array->_nrProbesA = 0;
array->_nrProbesD = 0;
array->_nrProbesR = 0;
}
static TRI_query_parser_t* InitParserQueryTemplate (TRI_query_template_t* const template_) {
TRI_query_parser_t* parser;
assert(template_);
assert(template_->_queryString);
parser = (TRI_query_parser_t*) TRI_Allocate(sizeof(TRI_query_parser_t));
if (!parser) {
TRI_SetQueryError(&template_->_error, TRI_ERROR_QUERY_OOM, NULL);
return NULL;
}
// init query data
parser->_length = strlen(template_->_queryString);
parser->_buffer = (char*) template_->_queryString;
// init lexer/scanner
QLlex_init(&parser->_scanner);
QLset_extra(template_, parser->_scanner);
return parser;
}
void TRI_InitMultiArray(TRI_multi_array_t* array,
TRI_memory_zone_t* zone,
size_t elementSize,
uint64_t (*hashKey) (TRI_multi_array_t*, void*),
uint64_t (*hashElement) (TRI_multi_array_t*, void*),
void (*clearElement) (TRI_multi_array_t*, void*),
bool (*isEmptyElement) (TRI_multi_array_t*, void*),
bool (*isEqualKeyElement) (TRI_multi_array_t*, void*, void*),
bool (*isEqualElementElement) (TRI_multi_array_t*, void*, void*)) {
array->hashKey = hashKey;
array->hashElement = hashElement;
array->clearElement = clearElement;
array->isEmptyElement = isEmptyElement;
array->isEqualKeyElement = isEqualKeyElement;
array->isEqualElementElement = isEqualElementElement;
array->_memoryZone = zone;
array->_elementSize = elementSize;
array->_nrAlloc = INITIAL_SIZE;
array->_table = TRI_Allocate(array->_memoryZone, array->_elementSize * array->_nrAlloc, true);
if (array->_table == NULL) {
array->_nrAlloc = 0;
}
array->_nrUsed = 0;
#ifdef TRI_INTERNAL_STATS
array->_nrFinds = 0;
array->_nrAdds = 0;
array->_nrRems = 0;
array->_nrResizes = 0;
array->_nrProbesF = 0;
array->_nrProbesA = 0;
array->_nrProbesD = 0;
array->_nrProbesR = 0;
#endif
}
TRI_query_node_t* TRI_CreateNodeQuery (TRI_vector_pointer_t* memory,
const TRI_query_node_type_e type) {
// allocate memory
TRI_query_node_t* node = (TRI_query_node_t *) TRI_Allocate(sizeof(TRI_query_node_t));
if (!node) {
return NULL;
}
// keep track of memory location
TRI_RegisterNodeQuery(memory, node);
// set node type
node->_type = type;
// set initial pointers to nil
node->_value._stringValue = NULL;
node->_lhs = NULL;
node->_rhs = NULL;
node->_next = NULL;
return node;
}
static TRI_shadow_t* CreateShadow (const void* const data) {
TRI_shadow_t* shadow = (TRI_shadow_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_shadow_t), false);
if (shadow == NULL) {
return NULL;
}
shadow->_rc = 1;
shadow->_data = (void*) data;
shadow->_id = TRI_NewTickVocBase();
shadow->_deleted = false;
shadow->_type = SHADOW_TRANSIENT;
UpdateTimestampShadow(shadow);
LOG_TRACE("created shadow %p with data ptr %p and id %llu",
shadow,
data,
(unsigned long long) shadow->_id);
return shadow;
}
TRI_shape_access_t* TRI_ShapeAccessor (TRI_shaper_t* shaper,
TRI_shape_sid_t sid,
TRI_shape_pid_t pid) {
TRI_shape_access_t* accessor;
bool ok;
accessor = TRI_Allocate(sizeof(TRI_shape_access_t));
if (!accessor) {
return NULL;
}
accessor->_sid = sid;
accessor->_pid = pid;
accessor->_code = NULL;
ok = BytecodeShapeAccessor(shaper, accessor);
if (ok) {
return accessor;
}
TRI_FreeShapeAccessor(accessor);
return NULL;
}
static char* NormaliseWord (const char* const word, const size_t wordLength) {
char* copy;
char* copy2;
char* copy3;
char* prefixEnd;
size_t outLength;
int32_t outLength2;
ptrdiff_t prefixLength;
// normalise string
copy = TRI_normalize_utf8_to_NFC(TRI_UNKNOWN_MEM_ZONE, word, wordLength, &outLength);
if (copy == NULL) {
return NULL;
}
// lower case string
copy2 = TRI_tolower_utf8(TRI_UNKNOWN_MEM_ZONE, copy, (int32_t) outLength, &outLength2);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, copy);
if (copy2 == NULL) {
return NULL;
}
prefixEnd = TRI_PrefixUtf8String(copy2, TRI_FULLTEXT_MAX_WORD_LENGTH);
prefixLength = prefixEnd - copy2;
copy3 = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(char) * ((size_t) prefixLength + 1), false);
if (copy3 == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, copy2);
return NULL;
}
memcpy(copy3, copy2, ((size_t) prefixLength) * sizeof(char));
copy3[prefixLength] = '\0';
TRI_Free(TRI_UNKNOWN_MEM_ZONE, copy2);
return copy3;
}
bool TRI_SliceSelectResult (TRI_select_result_t* result,
const TRI_voc_size_t skip,
const TRI_voc_ssize_t limit) {
TRI_sr_index_t* oldIndex;
TRI_sr_index_t* newIndex;
size_t newSize;
if (result->_numRows == 0 || !result->_index._start) {
// no need to do anything
return true;
}
// allocate new space for document index
newSize = (size_t) limit;
if (limit == 0) {
newSize = 1;
}
newIndex = (TRI_sr_index_t*) TRI_Allocate(newSize * sizeof(TRI_sr_index_t));
if (!newIndex) {
// error: memory allocation failed
return false;
}
oldIndex = (TRI_sr_index_t*) result->_index._start;
memcpy(newIndex, oldIndex + skip, limit * sizeof(TRI_sr_index_t));
TRI_Free(oldIndex);
result->_numRows = limit;
result->_index._start = newIndex;
result->_index._current = newIndex + 1;
result->_index._numAllocated = newSize;
result->_index._numUsed = (size_t) limit;
return true;
}
TRI_barrier_t* TRI_CreateBarrierDropDatafile (TRI_barrier_list_t* container,
TRI_datafile_t* datafile,
void (*callback) (struct TRI_datafile_s*, void*),
void* data) {
TRI_barrier_datafile_drop_cb_t* element;
element = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_barrier_datafile_drop_cb_t), false);
if (!element) {
return NULL;
}
element->base._type = TRI_BARRIER_DATAFILE_DROP_CALLBACK;
element->_datafile = datafile;
element->_data = data;
element->callback = callback;
LinkBarrierElement(&element->base, container);
return &element->base;
}
TRI_aql_statement_walker_t* TRI_CreateStatementWalkerAql (void* data,
const bool canModify,
TRI_aql_visit_f visitMember,
TRI_aql_visit_f preVisitStatement,
TRI_aql_visit_f postVisitStatement) {
TRI_aql_statement_walker_t* walker;
walker = (TRI_aql_statement_walker_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_statement_walker_t), false);
if (walker == NULL) {
return NULL;
}
walker->_data = data;
walker->_canModify = canModify;
walker->visitMember = visitMember;
walker->preVisitStatement = preVisitStatement;
walker->postVisitStatement = postVisitStatement;
TRI_InitVectorPointer(&walker->_currentScopes, TRI_UNKNOWN_MEM_ZONE);
return walker;
}
TRI_aql_variable_t* TRI_CreateVariableAql (const char* const name,
TRI_aql_node_t* const definingNode) {
TRI_aql_variable_t* variable;
variable = (TRI_aql_variable_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_variable_t), false);
if (variable == NULL) {
return NULL;
}
variable->_name = TRI_DuplicateString(name);
if (variable->_name == NULL) {
TRI_FreeVariableAql(variable);
return NULL;
}
variable->_definingNode = definingNode;
assert(definingNode);
return variable;
}
TRI_index_t* TRI_CreateCapConstraint (struct TRI_primary_collection_s* primary,
size_t size) {
TRI_cap_constraint_t* cap;
TRI_index_t* idx;
cap = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_cap_constraint_t), false);
idx = &cap->base;
idx->typeName = TypeNameCapConstraint;
TRI_InitIndex(idx, TRI_IDX_TYPE_CAP_CONSTRAINT, primary, false, true);
idx->json = JsonCapConstraint;
idx->removeIndex = RemoveIndexCapConstraint;
idx->insert = InsertCapConstraint;
idx->postInsert = PostInsertCapConstraint;
idx->remove = RemoveCapConstraint;
cap->_size = size;
InitialiseCap(cap, primary);
return idx;
}
TRI_barrier_t* TRI_CreateBarrierDropCollection (TRI_barrier_list_t* container,
struct TRI_collection_s* collection,
bool (*callback) (struct TRI_collection_s*, void*),
void* data) {
TRI_barrier_collection_cb_t* element;
element = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_barrier_collection_cb_t), false);
if (element == NULL) {
return NULL;
}
element->base._type = TRI_BARRIER_COLLECTION_DROP_CALLBACK;
element->_collection = collection;
element->_data = data;
element->callback = callback;
LinkBarrierElement(&element->base, container);
return &element->base;
}
