void APInt::Read(Deserializer& D) {
BitWidth = D.ReadInt();
if (isSingleWord())
VAL = D.ReadInt();
else {
uint32_t NumWords = D.ReadInt();
assert (NumWords > 1);
pVal = new uint64_t[NumWords];
assert (pVal && "Allocation in deserialization of APInt failed.");
for (unsigned i = 0; i < NumWords; ++i)
pVal[i] = D.ReadInt();
}
}
void QualType::ReadBackpatch(Deserializer& D) {
uintptr_t Val;
D.ReadUIntPtr(Val, false);
Value.setPointer(reinterpret_cast<Type*>(Val));
Value.setInt(D.ReadInt());
}
static int Deserializer_Read(duk_context* ctx)
{
duk_int_t magic = duk_get_current_magic(ctx);
duk_push_this(ctx);
// safe cast based on type check above
Deserializer* deserial = CastToDeserializer(ctx, duk_get_top_index(ctx));
duk_pop(ctx);
if (!deserial)
{
duk_push_boolean(ctx, 0);
return 1;
}
char* data;
String str;
size_t length;
IO_MAGIC_TYPE v = (IO_MAGIC_TYPE) magic;
bool success = false;
switch(v)
{
case IO_MAGIC_INT:
duk_push_number(ctx, (double) deserial->ReadInt());
return 1;
case IO_MAGIC_STRING:
length = deserial->GetSize() - deserial->GetPosition();
str.Resize(length + 1);
deserial->Read(&str[0], length);
str[length] = '\0';
duk_push_string(ctx, str.CString());
return 1;
case IO_MAGIC_ZEROSTRING:
success = duk_push_string(ctx, deserial->ReadString().CString());
return 1;
case IO_MAGIC_BINARY:
length = deserial->GetSize() - deserial->GetPosition();
duk_push_fixed_buffer(ctx, length);
duk_push_buffer_object(ctx, -1, 0, length, DUK_BUFOBJ_UINT8ARRAY);
duk_replace(ctx, -2);
data = (char*) duk_require_buffer_data(ctx, 0, &length);
success = deserial->Read(data, length);
return 1;
default:
break;
}
duk_push_undefined(ctx);
return 1;
}
static int Deserializer_Read(duk_context* ctx)
{
duk_int_t magic = duk_get_current_magic(ctx);
duk_push_this(ctx);
// safe cast based on type check above
Deserializer* deserial = CastToDeserializer(ctx, duk_get_top_index(ctx));
duk_pop(ctx);
if (!deserial)
{
duk_push_boolean(ctx, 0);
return 1;
}
PODVector<unsigned char> buffer;
String str;
size_t length;
IO_MAGIC_TYPE v = (IO_MAGIC_TYPE) magic;
bool success = false;
switch(v)
{
case IO_MAGIC_INT:
duk_push_number(ctx, (double) deserial->ReadInt());
return 1;
case IO_MAGIC_STRING:
length = deserial->GetSize() - deserial->GetPosition();
str.Resize(length + 1);
deserial->Read(&str[0], length);
str[length] = '\0';
duk_push_string(ctx, str.CString());
return 1;
case IO_MAGIC_ZEROSTRING:
success = duk_push_string(ctx, deserial->ReadString().CString());
return 1;
default:
break;
}
duk_push_undefined(ctx);
return 1;
}
bool DynamicNavigationMesh::ReadTiles(Deserializer& source, bool silent)
{
tileQueue_.Clear();
while (!source.IsEof())
{
dtTileCacheLayerHeader header; // NOLINT(hicpp-member-init)
source.Read(&header, sizeof(dtTileCacheLayerHeader));
const int dataSize = source.ReadInt();
auto* data = (unsigned char*)dtAlloc(dataSize, DT_ALLOC_PERM);
if (!data)
{
URHO3D_LOGERROR("Could not allocate data for navigation mesh tile");
return false;
}
source.Read(data, (unsigned)dataSize);
if (dtStatusFailed(tileCache_->addTile(data, dataSize, DT_TILE_FREE_DATA, nullptr)))
{
URHO3D_LOGERROR("Failed to add tile");
dtFree(data);
return false;
}
const IntVector2 tileIdx = IntVector2(header.tx, header.ty);
if (tileQueue_.Empty() || tileQueue_.Back() != tileIdx)
tileQueue_.Push(tileIdx);
}
for (unsigned i = 0; i < tileQueue_.Size(); ++i)
tileCache_->buildNavMeshTilesAt(tileQueue_[i].x_, tileQueue_[i].y_, navMesh_);
tileCache_->update(0, navMesh_);
// Send event
if (!silent)
{
for (unsigned i = 0; i < tileQueue_.Size(); ++i)
{
using namespace NavigationTileAdded;
VariantMap& eventData = GetContext()->GetEventDataMap();
eventData[P_NODE] = GetNode();
eventData[P_MESH] = this;
eventData[P_TILE] = tileQueue_[i];
SendEvent(E_NAVIGATION_TILE_ADDED, eventData);
}
}
return true;
}
bool Node::Load(Deserializer& source, bool setInstanceDefault)
{
SceneResolver resolver;
// Read own ID. Will not be applied, only stored for resolving possible references
unsigned nodeID = source.ReadInt();
resolver.AddNode(nodeID, this);
// Read attributes, components and child nodes
bool success = Load(source, resolver);
if (success)
{
resolver.Resolve();
ApplyAttributes();
}
return success;
}
void Type::Create(ASTContext& Context, unsigned i, Deserializer& D) {
Type::TypeClass K = static_cast<Type::TypeClass>(D.ReadInt());
SerializedPtrID PtrID = D.ReadPtrID();
switch (K) {
default:
assert (false && "Deserialization for type not supported.");
break;
case Type::Builtin:
assert (i < Context.getTypes().size());
assert (isa<BuiltinType>(Context.getTypes()[i]));
D.RegisterPtr(PtrID,Context.getTypes()[i]);
break;
case Type::ExtQual:
D.RegisterPtr(PtrID,ExtQualType::CreateImpl(Context,D));
break;
case Type::Complex:
D.RegisterPtr(PtrID,ComplexType::CreateImpl(Context,D));
break;
case Type::ConstantArray:
D.RegisterPtr(PtrID,ConstantArrayType::CreateImpl(Context,D));
break;
case Type::FunctionNoProto:
D.RegisterPtr(PtrID,FunctionNoProtoType::CreateImpl(Context,D));
break;
case Type::FunctionProto:
D.RegisterPtr(PtrID,FunctionProtoType::CreateImpl(Context,D));
break;
case Type::IncompleteArray:
D.RegisterPtr(PtrID,IncompleteArrayType::CreateImpl(Context,D));
break;
case Type::MemberPointer:
D.RegisterPtr(PtrID, MemberPointerType::CreateImpl(Context, D));
break;
case Type::Pointer:
D.RegisterPtr(PtrID, PointerType::CreateImpl(Context, D));
break;
case Type::BlockPointer:
D.RegisterPtr(PtrID, BlockPointerType::CreateImpl(Context, D));
break;
case Type::LValueReference:
D.RegisterPtr(PtrID, LValueReferenceType::CreateImpl(Context, D));
break;
case Type::RValueReference:
D.RegisterPtr(PtrID, RValueReferenceType::CreateImpl(Context, D));
break;
case Type::Record:
case Type::Enum:
// FIXME: Implement this!
assert(false && "Can't deserialize tag types!");
break;
case Type::Typedef:
D.RegisterPtr(PtrID, TypedefType::CreateImpl(Context, D));
break;
case Type::TypeOfExpr:
D.RegisterPtr(PtrID, TypeOfExprType::CreateImpl(Context, D));
break;
case Type::TypeOf:
D.RegisterPtr(PtrID, TypeOfType::CreateImpl(Context, D));
break;
case Type::TemplateTypeParm:
D.RegisterPtr(PtrID, TemplateTypeParmType::CreateImpl(Context, D));
break;
case Type::VariableArray:
D.RegisterPtr(PtrID, VariableArrayType::CreateImpl(Context, D));
break;
}
}
QualType QualType::ReadVal(Deserializer& D) {
uintptr_t Val;
D.ReadUIntPtr(Val, false);
return QualType(reinterpret_cast<Type*>(Val), D.ReadInt());
}
