static int AutoIncrementInit (TRI_key_generator_t* const generator, const TRI_json_t* const options) { autoincrement_keygen_t* data; data = (autoincrement_keygen_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(autoincrement_keygen_t), false); if (data == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } // defaults data->_allowUserKeys = true; data->_lastValue = 0; data->_offset = 0; data->_increment = 1; if (options != NULL) { TRI_json_t* option; option = TRI_LookupArrayJson(options, "allowUserKeys"); if (option != NULL && option->_type == TRI_JSON_BOOLEAN) { data->_allowUserKeys = option->_value._boolean; } option = TRI_LookupArrayJson(options, "increment"); if (option != NULL && option->_type == TRI_JSON_NUMBER) { data->_increment = (uint64_t) option->_value._number; if (data->_increment == 0 || data->_increment >= AUTOINCREMENT_MAX_INCREMENT) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); return TRI_ERROR_ARANGO_INVALID_KEY_GENERATOR; } } option = TRI_LookupArrayJson(options, "offset"); if (option != NULL && option->_type == TRI_JSON_NUMBER) { data->_offset = (uint64_t) option->_value._number; if (data->_offset >= AUTOINCREMENT_MAX_OFFSET) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); return TRI_ERROR_ARANGO_INVALID_KEY_GENERATOR; } } } generator->_data = (void*) data; LOG_TRACE("created autoincrement key-generator with options (allowUserKeys: %d, increment: %llu, offset: %llu)", (int) data->_allowUserKeys, (unsigned long long) data->_increment, (unsigned long long) data->_offset); return TRI_ERROR_NO_ERROR; }
void ImportHelper::handleResult (SimpleHttpResult* result) { if (! result) { return; } stringstream& r = result->getBody(); TRI_json_t* json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, r.str().c_str()); if (json) { // get the "error" flag. This returns a pointer, not a copy TRI_json_t* error = TRI_LookupArrayJson(json, "error"); if (error) { if (error->_type == TRI_JSON_BOOLEAN && error->_value._boolean) { _hasError = true; // get the error message. This returns a pointer, not a copy TRI_json_t* errorMessage = TRI_LookupArrayJson(json, "errorMessage"); if (TRI_IsStringJson(errorMessage)) { _errorMessage = string(errorMessage->_value._string.data, errorMessage->_value._string.length); } } } TRI_json_t* importResult; // look up the "created" flag. This returns a pointer, not a copy importResult= TRI_LookupArrayJson(json, "created"); if (importResult) { if (importResult->_type == TRI_JSON_NUMBER) { _numberOk += (size_t) importResult->_value._number; } } // look up the "errors" flag. This returns a pointer, not a copy importResult= TRI_LookupArrayJson(json, "errors"); if (importResult) { if (importResult->_type == TRI_JSON_NUMBER) { _numberError += (size_t) importResult->_value._number; } } // this will free the json struct will a sub-elements TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json); } delete result; }
uint64_t TRI_HashJsonByAttributes (TRI_json_t const* json, char const *attributes[], int nrAttributes, bool docComplete, int* error) { uint64_t hash; if (NULL != error) { *error = TRI_ERROR_NO_ERROR; } hash = TRI_FnvHashBlockInitial(); if (TRI_IsArrayJson(json)) { int i; for (i = 0; i < nrAttributes; i++) { TRI_json_t const* subjson = TRI_LookupArrayJson(json, attributes[i]); if (NULL == subjson && !docComplete && NULL != error) { *error = TRI_ERROR_CLUSTER_NOT_ALL_SHARDING_ATTRIBUTES_GIVEN; } hash = HashJsonRecursive(hash, subjson); } } return hash; }
static int TraditionalInit (TRI_key_generator_t* const generator, const TRI_json_t* const options) { traditional_keygen_t* data; data = (traditional_keygen_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(traditional_keygen_t), false); if (data == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } // defaults data->_allowUserKeys = true; if (options != NULL) { TRI_json_t* option; option = TRI_LookupArrayJson(options, "allowUserKeys"); if (option != NULL && option->_type == TRI_JSON_BOOLEAN) { data->_allowUserKeys = option->_value._boolean; } } generator->_data = (void*) data; LOG_TRACE("created traditional key-generator with options (allowUserKeys: %d)", (int) data->_allowUserKeys); return TRI_ERROR_NO_ERROR; }
static generator_type_e GeneratorType (const TRI_json_t* const parameters) { TRI_json_t* type; const char* typeName; if (parameters == NULL || parameters->_type != TRI_JSON_ARRAY) { return TYPE_TRADITIONAL; } type = TRI_LookupArrayJson(parameters, "type"); if (! TRI_IsStringJson(type)) { return TYPE_TRADITIONAL; } typeName = type->_value._string.data; if (TRI_CaseEqualString(typeName, TraditionalName)) { return TYPE_TRADITIONAL; } if (TRI_CaseEqualString(typeName, AutoIncrementName)) { return TYPE_AUTOINCREMENT; } // error return TYPE_UNKNOWN; }
void TRI_FromJsonVocBaseDefaults (TRI_vocbase_defaults_t* defaults, TRI_json_t const* json) { TRI_json_t* optionJson; if (! TRI_IsArrayJson(json)) { return; } optionJson = TRI_LookupArrayJson(json, "removeOnDrop"); if (TRI_IsBooleanJson(optionJson)) { defaults->removeOnDrop = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "removeOnCompacted"); if (TRI_IsBooleanJson(optionJson)) { defaults->removeOnCompacted = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "waitForSync"); if (TRI_IsBooleanJson(optionJson)) { defaults->defaultWaitForSync = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "forceSyncShapes"); if (TRI_IsBooleanJson(optionJson)) { defaults->forceSyncShapes = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "forceSyncProperties"); if (TRI_IsBooleanJson(optionJson)) { defaults->forceSyncProperties = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "requireAuthentication"); if (TRI_IsBooleanJson(optionJson)) { defaults->requireAuthentication = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "authenticateSystemOnly"); if (TRI_IsBooleanJson(optionJson)) { defaults->authenticateSystemOnly = optionJson->_value._boolean; } optionJson = TRI_LookupArrayJson(json, "defaultMaximalSize"); if (TRI_IsNumberJson(optionJson)) { defaults->defaultMaximalSize = (TRI_voc_size_t) optionJson->_value._number; } }
static TRI_json_t* MergeRecursive (TRI_memory_zone_t* zone, const TRI_json_t* const lhs, const TRI_json_t* const rhs, const bool nullMeansRemove) { size_t i, n; TRI_json_t* result = TRI_CopyJson(zone, lhs); if (result == NULL) { return NULL; } n = rhs->_value._objects._length; for (i = 0; i < n; i += 2) { // enumerate all the replacement values TRI_json_t* key = TRI_AtVector(&rhs->_value._objects, i); TRI_json_t* value = TRI_AtVector(&rhs->_value._objects, i + 1); if (value->_type == TRI_JSON_NULL && nullMeansRemove) { // replacement value is a null and we don't want to store nulls => delete attribute from the result TRI_DeleteArrayJson(zone, result, key->_value._string.data); } else { // replacement value is not a null or we want to store nulls TRI_json_t* lhsValue = TRI_LookupArrayJson(lhs, key->_value._string.data); if (lhsValue == NULL) { // existing array does not have the attribute => append new attribute if (value->_type == TRI_JSON_ARRAY) { TRI_json_t* empty = TRI_CreateArrayJson(zone); TRI_json_t* merged = MergeRecursive(zone, empty, value, nullMeansRemove); TRI_Insert3ArrayJson(zone, result, key->_value._string.data, merged); TRI_FreeJson(zone, empty); } else { TRI_Insert3ArrayJson(zone, result, key->_value._string.data, TRI_CopyJson(zone, value)); } } else { // existing array already has the attribute => replace attribute if (lhsValue->_type == TRI_JSON_ARRAY && value->_type == TRI_JSON_ARRAY) { TRI_json_t* merged = MergeRecursive(zone, lhsValue, value, nullMeansRemove); TRI_ReplaceArrayJson(zone, result, key->_value._string.data, merged); TRI_FreeJson(zone, merged); } else { TRI_ReplaceArrayJson(zone, result, key->_value._string.data, value); } } } } return result; }
static TRI_doc_mptr_t CreateJson (TRI_doc_collection_t* collection, TRI_df_marker_type_e type, TRI_json_t const* json, void const* data, bool reuseId, bool release) { TRI_shaped_json_t* shaped; TRI_doc_mptr_t result; TRI_voc_did_t did = 0; TRI_voc_rid_t rid = 0; shaped = TRI_ShapedJsonJson(collection->_shaper, json); if (shaped == 0) { collection->base._lastError = TRI_set_errno(TRI_ERROR_ARANGO_SHAPER_FAILED); memset(&result, 0, sizeof(result)); return result; } if (reuseId && json != NULL && json->_type == TRI_JSON_ARRAY) { TRI_json_t* id = TRI_LookupArrayJson((TRI_json_t*) json, "_id"); TRI_json_t* rev = TRI_LookupArrayJson((TRI_json_t*) json, "_rev"); if (id != NULL && id->_type == TRI_JSON_NUMBER && rev != NULL && rev->_type == TRI_JSON_NUMBER) { // read existing document id and revision id from document did = (TRI_voc_did_t) id->_value._number; rid = (TRI_voc_rid_t) rev->_value._number; } } result = collection->create(collection, type, shaped, data, did, rid, release); TRI_FreeShapedJson(collection->_shaper, shaped); return result; }
static int ReadTick (TRI_json_t const* json, char const* attributeName, TRI_voc_tick_t* dst) { TRI_json_t* tick; assert(json != NULL); assert(json->_type == TRI_JSON_ARRAY); tick = TRI_LookupArrayJson(json, attributeName); if (! TRI_IsStringJson(tick)) { return TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE; } *dst = (TRI_voc_tick_t) TRI_UInt64String2(tick->_value._string.data, tick->_value._string.length -1); return TRI_ERROR_NO_ERROR; }
double TRI_ToDoubleJson (TRI_json_t const* json, bool& failed) { TRI_ASSERT(json != nullptr); failed = false; switch (json->_type) { case TRI_JSON_UNUSED: case TRI_JSON_NULL: return 0.0; case TRI_JSON_BOOLEAN: return (json->_value._boolean ? 1.0 : 0.0); case TRI_JSON_NUMBER: return json->_value._number; case TRI_JSON_STRING: case TRI_JSON_STRING_REFERENCE: try { // try converting string to number double v = std::stod(json->_value._string.data); return v; } catch (...) { if (strlen(json->_value._string.data) == 0) { return 0.0; } // conversion failed } break; case TRI_JSON_ARRAY: { size_t const n = TRI_LengthArrayJson(json); if (n == 0) { return 0.0; } else if (n == 1) { return TRI_ToDoubleJson(TRI_LookupArrayJson(json, 0), failed); } break; } case TRI_JSON_OBJECT: break; } failed = true; // TODO: must convert to null here return 0.0; }
int64_t TRI_ToInt64Json (TRI_json_t const* json) { TRI_ASSERT(json != nullptr); switch (json->_type) { case TRI_JSON_UNUSED: case TRI_JSON_NULL: return 0; case TRI_JSON_BOOLEAN: return (json->_value._boolean ? 1 : 0); case TRI_JSON_NUMBER: return static_cast<int64_t>(json->_value._number); case TRI_JSON_STRING: case TRI_JSON_STRING_REFERENCE: try { // try converting string to number double v = std::stod(json->_value._string.data); return static_cast<int64_t>(v); } catch (...) { // conversion failed } break; case TRI_JSON_ARRAY: { size_t const n = TRI_LengthArrayJson(json); if (n == 0) { return 0; } else if (n == 1) { return TRI_ToInt64Json(TRI_LookupArrayJson(json, 0)); } break; } case TRI_JSON_OBJECT: break; } // TODO: must convert to null here return 0; }
KeyGenerator::GeneratorType KeyGenerator::generatorType (TRI_json_t const* parameters) { if (! TRI_IsArrayJson(parameters)) { return KeyGenerator::TYPE_TRADITIONAL; } TRI_json_t const* type = TRI_LookupArrayJson(parameters, "type"); if (! TRI_IsStringJson(type)) { return KeyGenerator::TYPE_TRADITIONAL; } char const* typeName = type->_value._string.data; if (TRI_CaseEqualString(typeName, TraditionalKeyGenerator::name().c_str())) { return KeyGenerator::TYPE_TRADITIONAL; } if (TRI_CaseEqualString(typeName, AutoIncrementKeyGenerator::name().c_str())) { return KeyGenerator::TYPE_AUTOINCREMENT; } // error return KeyGenerator::TYPE_UNKNOWN; }
DocumentAccessor& DocumentAccessor::at (int64_t index) { if (isArray()) { size_t length = TRI_LengthArrayJson(_current); if (index < 0) { // a negative position is allowed index = static_cast<int64_t>(length) + index; } if (index >= 0 && index < static_cast<int64_t>(length)) { // only look up the value if it is within array bounds TRI_json_t const* found = TRI_LookupArrayJson(_current, static_cast<size_t>(index)); if (found != nullptr) { _current = found; return *this; } } // fall-through intentional } setToNull(); return *this; }
static int TraditionalInit (TRI_key_generator_t* const generator, const TRI_json_t* const options) { traditional_keygen_t* data; data = (traditional_keygen_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(traditional_keygen_t), false); if (data == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } // defaults data->_allowUserKeys = true; // compile regex for key validation if (regcomp(&data->_regex, "^(" TRI_VOC_KEY_REGEX ")$", REG_EXTENDED | REG_NOSUB) != 0) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); LOG_ERROR("cannot compile regular expression"); return TRI_ERROR_INTERNAL; } if (options != NULL) { TRI_json_t* option; option = TRI_LookupArrayJson(options, "allowUserKeys"); if (option != NULL && option->_type == TRI_JSON_BOOLEAN) { data->_allowUserKeys = option->_value._boolean; } } generator->_data = (void*) data; LOG_TRACE("created traditional key-generator with options (allowUserKeys: %d)", (int) data->_allowUserKeys); return TRI_ERROR_NO_ERROR; }
static int LoadConfiguration (TRI_vocbase_t* vocbase, TRI_replication_applier_configuration_t* config) { TRI_json_t* json; TRI_json_t* value; char* filename; int res; TRI_DestroyConfigurationReplicationApplier(config); TRI_InitConfigurationReplicationApplier(config); filename = GetConfigurationFilename(vocbase); if (! TRI_ExistsFile(filename)) { TRI_FreeString(TRI_CORE_MEM_ZONE, filename); return TRI_ERROR_FILE_NOT_FOUND; } json = TRI_JsonFile(TRI_CORE_MEM_ZONE, filename, NULL); TRI_FreeString(TRI_CORE_MEM_ZONE, filename); if (! TRI_IsArrayJson(json)) { if (json != NULL) { TRI_FreeJson(TRI_CORE_MEM_ZONE, json); } return TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION; } res = TRI_ERROR_NO_ERROR; if (config->_endpoint != NULL) { TRI_FreeString(TRI_CORE_MEM_ZONE, config->_endpoint); config->_endpoint = NULL; } if (config->_database != NULL) { TRI_FreeString(TRI_CORE_MEM_ZONE, config->_database); config->_database = NULL; } if (config->_username != NULL) { TRI_FreeString(TRI_CORE_MEM_ZONE, config->_username); config->_username = NULL; } if (config->_password != NULL) { TRI_FreeString(TRI_CORE_MEM_ZONE, config->_password); config->_password = NULL; } // read the endpoint value = TRI_LookupArrayJson(json, "endpoint"); if (! TRI_IsStringJson(value)) { res = TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION; } else { config->_endpoint = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE, value->_value._string.data, value->_value._string.length - 1); } // read the database name value = TRI_LookupArrayJson(json, "database"); if (! TRI_IsStringJson(value)) { config->_database = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, vocbase->_name); } else { config->_database = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE, value->_value._string.data, value->_value._string.length - 1); } // read username / password value = TRI_LookupArrayJson(json, "username"); if (TRI_IsStringJson(value)) { config->_username = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE, value->_value._string.data, value->_value._string.length - 1); } value = TRI_LookupArrayJson(json, "password"); if (TRI_IsStringJson(value)) { config->_password = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE, value->_value._string.data, value->_value._string.length - 1); } value = TRI_LookupArrayJson(json, "requestTimeout"); if (TRI_IsNumberJson(value)) { config->_requestTimeout = value->_value._number; } value = TRI_LookupArrayJson(json, "connectTimeout"); if (TRI_IsNumberJson(value)) { config->_connectTimeout = value->_value._number; } value = TRI_LookupArrayJson(json, "maxConnectRetries"); if (TRI_IsNumberJson(value)) { config->_maxConnectRetries = (uint64_t) value->_value._number; } value = TRI_LookupArrayJson(json, "chunkSize"); if (TRI_IsNumberJson(value)) { config->_chunkSize = (uint64_t) value->_value._number; } value = TRI_LookupArrayJson(json, "autoStart"); if (TRI_IsBooleanJson(value)) { config->_autoStart = value->_value._boolean; } value = TRI_LookupArrayJson(json, "adaptivePolling"); if (TRI_IsBooleanJson(value)) { config->_adaptivePolling = value->_value._boolean; } TRI_FreeJson(TRI_CORE_MEM_ZONE, json); return res; }
int TRI_LoadStateReplicationApplier (TRI_vocbase_t* vocbase, TRI_replication_applier_state_t* state) { TRI_json_t* json; TRI_json_t* serverId; char* filename; int res; TRI_InitStateReplicationApplier(state); filename = GetStateFilename(vocbase); if (filename == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } LOG_TRACE("looking for replication state file '%s'", filename); if (! TRI_ExistsFile(filename)) { TRI_FreeString(TRI_CORE_MEM_ZONE, filename); return TRI_ERROR_FILE_NOT_FOUND; } LOG_TRACE("replication state file '%s' found", filename); json = TRI_JsonFile(TRI_CORE_MEM_ZONE, filename, NULL); TRI_FreeString(TRI_CORE_MEM_ZONE, filename); if (! TRI_IsArrayJson(json)) { if (json != NULL) { TRI_FreeJson(TRI_CORE_MEM_ZONE, json); } return TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE; } res = TRI_ERROR_NO_ERROR; // read the server id serverId = TRI_LookupArrayJson(json, "serverId"); if (! TRI_IsStringJson(serverId)) { res = TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE; } else { state->_serverId = TRI_UInt64String2(serverId->_value._string.data, serverId->_value._string.length - 1); } if (res == TRI_ERROR_NO_ERROR) { // read the ticks res |= ReadTick(json, "lastAppliedContinuousTick", &state->_lastAppliedContinuousTick); // set processed = applied state->_lastProcessedContinuousTick = state->_lastAppliedContinuousTick; } TRI_FreeJson(TRI_CORE_MEM_ZONE, json); LOG_TRACE("replication state file read successfully"); return res; }
int TRI_CompareValuesJson (const TRI_json_t* const lhs, const TRI_json_t* const rhs) { // note: both lhs and rhs may be NULL! int lWeight = TypeWeight(lhs); int rWeight = TypeWeight(rhs); if (lWeight < rWeight) { return -1; } if (lWeight > rWeight) { return 1; } // lhs and rhs have equal weights if (lhs == NULL) { // both lhs and rhs are NULL, so they are equal return 0; } switch (lhs->_type) { case TRI_JSON_UNUSED: case TRI_JSON_NULL: return 0; // null == null; case TRI_JSON_BOOLEAN: if (lhs->_value._boolean == rhs->_value._boolean) { return 0; } if (!lhs->_value._boolean && rhs->_value._boolean) { return -1; } return 1; case TRI_JSON_NUMBER: if (lhs->_value._number == rhs->_value._number) { return 0; } if (lhs->_value._number < rhs->_value._number) { return -1; } return 1; case TRI_JSON_STRING: return strcmp(lhs->_value._string.data, rhs->_value._string.data); case TRI_JSON_LIST: { size_t nl = lhs->_value._objects._length; size_t nr = rhs->_value._objects._length; size_t n; size_t i; if (nl > nr) { n = nl; } else { n = nr; } for (i = 0; i < n; ++i) { TRI_json_t* lhsValue; TRI_json_t* rhsValue; int result; lhsValue = (i >= nl) ? NULL : TRI_AtVector(&lhs->_value._objects, i); rhsValue = (i >= nr) ? NULL : TRI_AtVector(&rhs->_value._objects, i); result = TRI_CompareValuesJson(lhsValue, rhsValue); if (result != 0) { return result; } } return 0; } case TRI_JSON_ARRAY: { TRI_json_t* keys; assert(lhs->_type == TRI_JSON_ARRAY); assert(rhs->_type == TRI_JSON_ARRAY); keys = GetMergedKeyList(lhs, rhs); if (keys != NULL) { size_t i, n; n = keys->_value._objects._length; for (i = 0; i < n; ++i) { TRI_json_t* keyElement; TRI_json_t* lhsValue; TRI_json_t* rhsValue; int result; keyElement = TRI_AtVector(&keys->_value._objects, i); assert(keyElement->_type == TRI_JSON_STRING); assert(keyElement->_value._string.data); lhsValue = TRI_LookupArrayJson((TRI_json_t*) lhs, keyElement->_value._string.data); // may be NULL rhsValue = TRI_LookupArrayJson((TRI_json_t*) rhs, keyElement->_value._string.data); // may be NULL result = TRI_CompareValuesJson(lhsValue, rhsValue); if (result != 0) { TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, keys); return result; } } TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, keys); } return 0; } default: return 0; } }
KeyGenerator* KeyGenerator::factory (TRI_json_t const* options) { KeyGenerator::GeneratorType type; bool const readOptions = TRI_IsArrayJson(options); if (readOptions) { type = generatorType(options); } else { type = TYPE_TRADITIONAL; } if (type == TYPE_UNKNOWN) { return nullptr; } bool allowUserKeys = true; if (readOptions) { TRI_json_t* option = TRI_LookupArrayJson(options, "allowUserKeys"); if (TRI_IsBooleanJson(option)) { allowUserKeys = option->_value._boolean; } } if (type == TYPE_TRADITIONAL) { return new TraditionalKeyGenerator(allowUserKeys); } else if (type == TYPE_AUTOINCREMENT) { uint64_t offset = 0; uint64_t increment = 1; if (readOptions) { TRI_json_t* option; option = TRI_LookupArrayJson(options, "increment"); if (TRI_IsNumberJson(option)) { increment = (uint64_t) option->_value._number; if (increment == 0 || increment >= (1ULL << 16)) { return nullptr; } } option = TRI_LookupArrayJson(options, "offset"); if (TRI_IsNumberJson(option)) { offset = (uint64_t) option->_value._number; if (offset >= UINT64_MAX) { return nullptr; } } } return new AutoIncrementKeyGenerator(allowUserKeys, offset, increment); } return nullptr; }
void ImportHelper::handleResult (SimpleHttpResult* result) { if (result == 0) { return; } TRI_json_t* json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, result->getBody().c_str()); if (json != 0) { // error details TRI_json_t const* details = TRI_LookupArrayJson(json, "details"); if (TRI_IsListJson(details)) { const size_t n = details->_value._objects._length; for (size_t i = 0; i < n; ++i) { TRI_json_t const* detail = (TRI_json_t const*) TRI_AtVector(&details->_value._objects, i); if (TRI_IsStringJson(detail)) { LOG_WARNING("%s", detail->_value._string.data); } } } // get the "error" flag. This returns a pointer, not a copy TRI_json_t const* error = TRI_LookupArrayJson(json, "error"); if (TRI_IsBooleanJson(error) && error->_value._boolean) { _hasError = true; // get the error message. This returns a pointer, not a copy TRI_json_t const* errorMessage = TRI_LookupArrayJson(json, "errorMessage"); if (TRI_IsStringJson(errorMessage)) { _errorMessage = string(errorMessage->_value._string.data, errorMessage->_value._string.length - 1); } } TRI_json_t const* importResult; // look up the "created" flag. This returns a pointer, not a copy importResult = TRI_LookupArrayJson(json, "created"); if (TRI_IsNumberJson(importResult)) { _numberOk += (size_t) importResult->_value._number; } // look up the "errors" flag. This returns a pointer, not a copy importResult = TRI_LookupArrayJson(json, "errors"); if (TRI_IsNumberJson(importResult)) { _numberError += (size_t) importResult->_value._number; } // this will free the json struct will a sub-elements TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json); } delete result; }
static int AutoIncrementInit (TRI_key_generator_t* const generator, const TRI_json_t* const options) { autoincrement_keygen_t* data; data = (autoincrement_keygen_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(autoincrement_keygen_t), false); if (data == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } // defaults data->_allowUserKeys = true; data->_lastValue = 0; data->_offset = 0; data->_increment = 1; // compile regex for key validation if (regcomp(&data->_regex, "^(" TRI_VOC_ID_REGEX ")$", REG_EXTENDED | REG_NOSUB) != 0) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); LOG_ERROR("cannot compile regular expression"); return TRI_ERROR_INTERNAL; } if (options != NULL) { TRI_json_t* option; option = TRI_LookupArrayJson(options, "allowUserKeys"); if (option != NULL && option->_type == TRI_JSON_BOOLEAN) { data->_allowUserKeys = option->_value._boolean; } option = TRI_LookupArrayJson(options, "increment"); if (option != NULL && option->_type == TRI_JSON_NUMBER) { data->_increment = (uint64_t) option->_value._number; if (data->_increment == 0 || data->_increment >= AUTOINCREMENT_MAX_INCREMENT) { regfree(&data->_regex); TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); return TRI_ERROR_BAD_PARAMETER; } } option = TRI_LookupArrayJson(options, "offset"); if (option != NULL && option->_type == TRI_JSON_NUMBER) { data->_offset = (uint64_t) option->_value._number; if (data->_offset >= AUTOINCREMENT_MAX_OFFSET) { regfree(&data->_regex); TRI_Free(TRI_UNKNOWN_MEM_ZONE, data); return TRI_ERROR_BAD_PARAMETER; } } } generator->_data = (void*) data; LOG_TRACE("created autoincrement key-generator with options (allowUserKeys: %d, increment: %llu, offset: %llu)", (int) data->_allowUserKeys, (unsigned long long) data->_increment, (unsigned long long) data->_offset); return TRI_ERROR_NO_ERROR; }
static bool isEqualJson(TRI_json_t* left, TRI_json_t* right) { if (left == NULL && right == NULL) { return true; } if (left == NULL || right == NULL) { return false; } if (left->_type != right->_type) { return false; } switch (left->_type) { case TRI_JSON_UNUSED: { return true; } case TRI_JSON_NULL: { return true; } case TRI_JSON_BOOLEAN: { return (left->_value._boolean == right->_value._boolean); } case TRI_JSON_NUMBER: { return (left->_value._number == right->_value._number); } case TRI_JSON_STRING: { return (strcmp(left->_value._string.data, right->_value._string.data) == 0); } case TRI_JSON_ARRAY: { int j; if (left->_value._objects._length != right->_value._objects._length) { return false; } for (j = 0; j < (left->_value._objects._length / 2); ++j) { TRI_json_t* leftName; TRI_json_t* leftValue; TRI_json_t* rightValue; leftName = (TRI_json_t*)(TRI_AtVector(&(left->_value._objects),2*j)); if (leftName == NULL) { return false; } leftValue = (TRI_json_t*)(TRI_AtVector(&(left->_value._objects),(2*j) + 1)); rightValue = TRI_LookupArrayJson(right, leftName->_value._string.data); if (isEqualJson(leftValue, rightValue)) { continue; } return false; } return true; } case TRI_JSON_LIST: { int j; if (left->_value._objects._length != right->_value._objects._length) { return false; } for (j = 0; j < left->_value._objects._length; ++j) { TRI_json_t* subLeft; TRI_json_t* subRight; subLeft = (TRI_json_t*)(TRI_AtVector(&(left->_value._objects),j)); subRight = (TRI_json_t*)(TRI_AtVector(&(right->_value._objects),j)); if (isEqualJson(subLeft, subRight)) { continue; } return false; } return true; } default: { assert(false); } } return false; // shut the vc++ up }