// ************************************************************
void
testValueSerialize (void)
{
testName = "test value serialization and deserialization";
ASSERT_EQUALS_STRING(serializeValue(stringToValue("i10")), "10", "create Value 10");
ASSERT_EQUALS_STRING(serializeValue(stringToValue("f5.3")), "5.300000", "create Value 5.3");
ASSERT_EQUALS_STRING(serializeValue(stringToValue("sHello World")), "Hello World", "create Value Hello World");
ASSERT_EQUALS_STRING(serializeValue(stringToValue("bt")), "true", "create Value true");
ASSERT_EQUALS_STRING(serializeValue(stringToValue("btrue")), "true", "create Value true");
TEST_DONE();
}
void Serializer::serializeNullableBegin(const std::string& name, bool isNull)
{
if (isNull)
{
serializeValue(name, v8::Null(_pIsolate));
}
}
void Serializer::serializeSequenceEnd(const std::string& name)
{
v8::Local<v8::Object> object = _jsObjectStack.back();
_jsObjectStack.pop_back();
_jsIndexStack.pop_back();
serializeValue(name, object);
}
void Serializer::serialize(const std::string& name, const std::vector<char>& value)
{
Poco::JS::Core::BufferWrapper::Buffer* pBuffer = new Poco::JS::Core::BufferWrapper::Buffer(&value[0], value.size());
Poco::JS::Core::BufferWrapper wrapper;
v8::Persistent<v8::Object>& bufferObject(wrapper.wrapNativePersistent(_pIsolate, pBuffer));
v8::Local<v8::Object> localBufferObject = v8::Local<v8::Object>::New(_pIsolate, bufferObject);
serializeValue(name, localBufferObject);
}
static void serializeElement(MemoryBuffer & target, IDefRecordElement * elem)
{
byte kind = elem ? elem->getKind() : DEKnone;
target.append(kind);
switch (kind)
{
case DEKnone:
break;
case DEKrecord:
{
size32_t maxSize = elem->getMaxSize();
unsigned numChildren = elem->numChildren();
target.append(maxSize).append(numChildren);
for (unsigned i=0; i < numChildren; i++)
serializeElement(target, elem->queryChild(i));
break;
}
case DEKifblock:
{
IValue * value = elem->queryCompareValue();
serializeValue(target, value);
serializeElement(target, elem->queryChild(0));
serializeElement(target, elem->queryChild(1));
break;
}
case DEKfield:
{
_ATOM name = elem->queryName();
ITypeInfo * type = elem->queryType();
size32_t maxSize = elem->getMaxSize();
serializeAtom(target, name);
type->serialize(target);
serializeElement(target, elem->queryChild(0));
target.append(maxSize);
break;
}
default:
throwUnexpected();
}
}
void Serializer::serialize(const std::string& name, const std::string& value)
{
serializeValue(name, v8::String::NewFromUtf8(_pIsolate, value.c_str(), v8::String::kNormalString, static_cast<int>(value.size())));
}
void Serializer::serialize(const std::string& name, char value)
{
serializeValue(name, v8::String::NewFromUtf8(_pIsolate, &value, v8::String::kNormalString, 1));
}
void Serializer::serialize(const std::string& name, bool value)
{
serializeValue(name, v8::Boolean::New(_pIsolate, value));
}
void Serializer::serialize(const std::string& name, double value)
{
serializeValue(name, v8::Number::New(_pIsolate, value));
}
void Serializer::serialize(const std::string& name, Poco::UInt64 value)
{
serializeValue(name, v8::Number::New(_pIsolate, value));
}
void Serializer::serialize(const std::string& name, unsigned long value)
{
serializeValue(name, v8::Number::New(_pIsolate, value));
}
void Serializer::serialize(const std::string& name, Poco::UInt32 value)
{
serializeValue(name, v8::Integer::NewFromUnsigned(_pIsolate, value));
}
void Serializer::serialize(const std::string& name, Poco::UInt16 value)
{
serializeValue(name, v8::Integer::NewFromUnsigned(_pIsolate, static_cast<Poco::UInt32>(value)));
}
void Serializer::serialize(const std::string& name, Poco::UInt64 value)
{
serializeValue(name, v8::Number::New(_pIsolate, static_cast<double>(value)));
}
