void VelocyPackHelper::initialize() {
LOG(TRACE) << "initializing vpack";
// initialize attribute translator
Translator.reset(new VPackAttributeTranslator);
// these attribute names will be translated into short integer values
Translator->add(StaticStrings::KeyString, KeyAttribute - AttributeBase);
Translator->add(StaticStrings::RevString, RevAttribute - AttributeBase);
Translator->add(StaticStrings::IdString, IdAttribute - AttributeBase);
Translator->add(StaticStrings::FromString, FromAttribute - AttributeBase);
Translator->add(StaticStrings::ToString, ToAttribute - AttributeBase);
Translator->seal();
// set the attribute translator in the global options
VPackOptions::Defaults.attributeTranslator = Translator.get();
VPackOptions::Defaults.unsupportedTypeBehavior = VPackOptions::ConvertUnsupportedType;
// run quick selfs test with the attribute translator
TRI_ASSERT(VPackSlice(Translator->translate(StaticStrings::KeyString)).getUInt() == KeyAttribute - AttributeBase);
TRI_ASSERT(VPackSlice(Translator->translate(StaticStrings::RevString)).getUInt() == RevAttribute - AttributeBase);
TRI_ASSERT(VPackSlice(Translator->translate(StaticStrings::IdString)).getUInt() == IdAttribute - AttributeBase);
TRI_ASSERT(VPackSlice(Translator->translate(StaticStrings::FromString)).getUInt() == FromAttribute - AttributeBase);
TRI_ASSERT(VPackSlice(Translator->translate(StaticStrings::ToString)).getUInt() == ToAttribute - AttributeBase);
TRI_ASSERT(VPackSlice(Translator->translate(KeyAttribute - AttributeBase)).copyString() == StaticStrings::KeyString);
TRI_ASSERT(VPackSlice(Translator->translate(RevAttribute - AttributeBase)).copyString() == StaticStrings::RevString);
TRI_ASSERT(VPackSlice(Translator->translate(IdAttribute - AttributeBase)).copyString() == StaticStrings::IdString);
TRI_ASSERT(VPackSlice(Translator->translate(FromAttribute - AttributeBase)).copyString() == StaticStrings::FromString);
TRI_ASSERT(VPackSlice(Translator->translate(ToAttribute - AttributeBase)).copyString() == StaticStrings::ToString);
// initialize exclude handler for system attributes
ExcludeHandler.reset(new SystemAttributeExcludeHandler);
}
std::string VelocyPackHelper::getStringValue(VPackSlice slice,
std::string const& name,
std::string const& defaultValue) {
if (slice.isExternal()) {
slice = VPackSlice(slice.getExternal());
}
TRI_ASSERT(slice.isObject());
if (!slice.hasKey(name)) {
return defaultValue;
}
VPackSlice const sub = slice.get(name);
if (!sub.isString()) {
return defaultValue;
}
return sub.copyString();
}
v8::Handle<v8::Value> TRI_VPackToV8(v8::Isolate* isolate,
VPackSlice const& slice,
VPackOptions const* options,
VPackSlice const* base) {
switch (slice.type()) {
case VPackValueType::Null: {
return v8::Null(isolate);
}
case VPackValueType::Bool: {
return v8::Boolean::New(isolate, slice.getBool());
}
case VPackValueType::Double: {
// convert NaN, +inf & -inf to null
double value = slice.getDouble();
if (std::isnan(value) || !std::isfinite(value) || value == HUGE_VAL || value == -HUGE_VAL) {
return v8::Null(isolate);
}
return v8::Number::New(isolate, slice.getDouble());
}
case VPackValueType::Int: {
int64_t value = slice.getInt();
if (value >= -2147483648LL && value <= 2147483647LL) {
// value is within bounds of an int32_t
return v8::Integer::New(isolate, static_cast<int32_t>(value));
}
if (value >= 0 && value <= 4294967295LL) {
// value is within bounds of a uint32_t
return v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(value));
}
// must use double to avoid truncation
return v8::Number::New(isolate, static_cast<double>(slice.getInt()));
}
case VPackValueType::UInt: {
uint64_t value = slice.getUInt();
if (value <= 4294967295ULL) {
// value is within bounds of a uint32_t
return v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(value));
}
// must use double to avoid truncation
return v8::Number::New(isolate, static_cast<double>(slice.getUInt()));
}
case VPackValueType::SmallInt: {
return v8::Integer::New(isolate, slice.getNumericValue<int32_t>());
}
case VPackValueType::String: {
return ObjectVPackString(isolate, slice);
}
case VPackValueType::Array: {
return ObjectVPackArray(isolate, slice, options, base);
}
case VPackValueType::Object: {
return ObjectVPackObject(isolate, slice, options, base);
}
case VPackValueType::External: {
// resolve external
return TRI_VPackToV8(isolate, VPackSlice(slice.getExternal()), options, base);
}
case VPackValueType::Custom: {
if (options == nullptr || options->customTypeHandler == nullptr || base == nullptr) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL,
"Could not extract custom attribute.");
}
std::string id =
options->customTypeHandler->toString(slice, options, *base);
return TRI_V8_STD_STRING(id);
}
case VPackValueType::None:
default: {
return v8::Undefined(isolate);
}
}
}