v8::Local<v8::Value> SerializedScriptValueForModulesFactory::deserialize(
SerializedScriptValue* value,
v8::Isolate* isolate,
MessagePortArray* messagePorts,
const WebBlobInfoArray* blobInfo) {
if (RuntimeEnabledFeatures::v8BasedStructuredCloneEnabled()) {
V8ScriptValueDeserializerForModules deserializer(
ScriptState::current(isolate), value);
deserializer.setTransferredMessagePorts(messagePorts);
deserializer.setBlobInfoArray(blobInfo);
return deserializer.deserialize();
}
// deserialize() can run arbitrary script (e.g., setters), which could result
// in |this| being destroyed. Holding a RefPtr ensures we are alive (along
// with our internal data) throughout the operation.
RefPtr<SerializedScriptValue> protect(value);
String& data = value->data();
if (!data.impl())
return v8::Null(isolate);
static_assert(sizeof(SerializedScriptValueWriter::BufferValueType) == 2,
"BufferValueType should be 2 bytes");
data.ensure16Bit();
// FIXME: SerializedScriptValue shouldn't use String for its underlying
// storage. Instead, it should use SharedBuffer or Vector<uint8_t>. The
// information stored in m_data isn't even encoded in UTF-16. Instead,
// unicode characters are encoded as UTF-8 with two code units per UChar.
SerializedScriptValueReaderForModules reader(
reinterpret_cast<const uint8_t*>(data.impl()->characters16()),
2 * data.length(), blobInfo, value->blobDataHandles(),
ScriptState::current(isolate));
ScriptValueDeserializerForModules deserializer(
reader, messagePorts, value->getArrayBufferContentsArray(),
value->getImageBitmapContentsArray());
return deserializer.deserialize();
}
already_AddRefed<gfxImageSurface>
BufferTextureHost::GetAsSurface()
{
nsRefPtr<gfxImageSurface> result;
if (mFormat == gfx::FORMAT_UNKNOWN) {
NS_WARNING("BufferTextureHost: unsupported format!");
return nullptr;
} else if (mFormat == gfx::FORMAT_YUV) {
YCbCrImageDataDeserializer yuvDeserializer(GetBuffer());
if (!yuvDeserializer.IsValid()) {
return nullptr;
}
result = new gfxImageSurface(yuvDeserializer.GetYData(),
yuvDeserializer.GetYSize(),
yuvDeserializer.GetYStride(),
gfxASurface::ImageFormatA8);
} else {
ImageDataDeserializer deserializer(GetBuffer());
if (!deserializer.IsValid()) {
return nullptr;
}
RefPtr<gfxImageSurface> surf = deserializer.GetAsThebesSurface();
result = surf.get();
}
return result.forget();
}
TemporaryRef<gfx::DataSourceSurface>
BufferTextureHost::GetAsSurface()
{
RefPtr<gfx::DataSourceSurface> result;
if (mFormat == gfx::SurfaceFormat::UNKNOWN) {
NS_WARNING("BufferTextureHost: unsupported format!");
return nullptr;
} else if (mFormat == gfx::SurfaceFormat::YUV) {
YCbCrImageDataDeserializer yuvDeserializer(GetBuffer(), GetBufferSize());
if (!yuvDeserializer.IsValid()) {
return nullptr;
}
result = yuvDeserializer.ToDataSourceSurface();
if (NS_WARN_IF(!result)) {
return nullptr;
}
} else {
ImageDataDeserializer deserializer(GetBuffer(), GetBufferSize());
if (!deserializer.IsValid()) {
NS_ERROR("Failed to deserialize image!");
return nullptr;
}
result = deserializer.GetAsSurface();
}
return result.forget();
}
void ConvertImageToRGB(const SurfaceDescriptor& aImage)
{
YCbCrImageDataDeserializer deserializer(aImage.get_YCbCrImage().data().get<uint8_t>());
PlanarYCbCrImage::Data data;
DeserializerToPlanarYCbCrImageData(deserializer, data);
gfxASurface::gfxImageFormat format = gfxASurface::ImageFormatRGB24;
gfxIntSize size;
gfxUtils::GetYCbCrToRGBDestFormatAndSize(data, format, size);
if (size.width > PlanarYCbCrImage::MAX_DIMENSION ||
size.height > PlanarYCbCrImage::MAX_DIMENSION) {
NS_ERROR("Illegal image dest width or height");
return;
}
mThebesSurface = mThebesImage =
new gfxImageSurface(size, format);
gfxUtils::ConvertYCbCrToRGB(data, format, size,
mThebesImage->Data(),
mThebesImage->Stride());
mSize = IntSize(size.width, size.height);
mFormat =
(format == gfxASurface::ImageFormatARGB32) ? FORMAT_B8G8R8A8 :
FORMAT_B8G8R8X8;
}
HRESULT
AccessibleHandler::ReadHandlerPayload(IStream* aStream, REFIID aIid)
{
if (!aStream) {
return E_INVALIDARG;
}
mscom::StructFromStream deserializer(aStream);
if (!deserializer) {
return E_FAIL;
}
if (deserializer.IsEmpty()) {
return S_FALSE;
}
if (!deserializer.Read(&mCachedData, &IA2Payload_Decode)) {
return E_FAIL;
}
if (!mCachedData.mGeckoBackChannel) {
return S_OK;
}
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
if (!ctl) {
return E_OUTOFMEMORY;
}
return ctl->Register(WrapNotNull(mCachedData.mGeckoBackChannel));
}
TEST(SaveableOperators, Bitset)
{
kv::FastSerializer serializer;
for (int i = 0; i < 16; ++i)
{
serializer << std::bitset<4>(i);
}
kv::FastDeserializer deserializer(
serializer.GetData(),
serializer.GetIndex());
std::bitset<4> value;
const int CHECK_ARRAY[] = {0b0000, 0b0001, 0b0010, 0b0011, 0b0100, 0b0101, 0b0110, 0b0111,
0b1000, 0b1001, 0b1010, 0b1011, 0b1100, 0b1101, 0b1110, 0b1111};
for (int check_value = 0; check_value < 16; ++check_value)
{
deserializer >> value;
EXPECT_EQ(value, CHECK_ARRAY[check_value]);
EXPECT_EQ(kv::Hash(value), CHECK_ARRAY[check_value]);
}
}
void GRTags::findSymbols(const ByteArray &pattern)
{
std::string value;
if (mDB->Get(leveldb::ReadOptions(), leveldb::Slice(pattern.constData(), pattern.size()), &value).ok()) {
Deserializer deserializer(value.c_str(), value.size());
Map<Location, bool> symbols;
deserializer >> symbols;
for (Map<Location, bool>::const_iterator it = symbols.begin(); it != symbols.end(); ++it) {
bool ok;
switch (mMode) {
case FindSymbols:
ok = !it->second;
break;
case FindReferences:
ok = it->second;
break;
case FindAll:
ok = true;
break;
default:
assert(0);
return;
}
if (ok) {
error() << it->first.key(mKeyFlags);
}
}
}
PyObject* py_loadTransferFunction(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
std::string path;
std::string filename;
if (tester.parse(args, path, filename) == -1) {
return nullptr;
}
auto tf = getTF(path, "loadTransferFunction");
if (!tf) { return nullptr; }
auto app = InviwoApplication::getPtr();
if (!filesystem::fileExists(filename)) {
if (filesystem::fileExists(app->getPath(PathType::TransferFunctions, "/" + filename))) {
filename = app->getPath(PathType::TransferFunctions, "/" + filename);
} else {
std::string msg = "loadTransferFunction() file not found (" + filename + ")";
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
}
Deserializer deserializer(app, filename);
tf->deserialize(deserializer);
Py_RETURN_NONE;
}
SirenObject Deserialize(const MemoryData& data, const ISirenType& type, SirenCoderType coder /*= SirenCoderType::Compact*/)
{
switch (coder)
{
case SirenCoderType::Compact:
{
SirenObject obj;
MemoryStream stream(data);
SirenCompactBinaryReader reader(stream);
SirenObjectDeserializer deserializer(reader);
if (deserializer.Deserialize(obj, type))
{
return obj;
}
return SirenObject::Null;
}
case SirenCoderType::Fast:
{
SirenObject obj;
MemoryStream stream(data);
SirenFastBinaryReader reader(stream);
SirenObjectDeserializer deserializer(reader);
if (deserializer.Deserialize(obj, type))
{
return obj;
}
return SirenObject::Null;
}
case SirenCoderType::Json:
{
SirenObject obj;
MemoryStream stream(data);
SirenJsonReader reader(stream);
SirenObjectDeserializer deserializer(reader);
if (deserializer.Deserialize(obj, type))
{
return obj;
}
return SirenObject::Null;
}
}
return SirenObject::Null;
}
bool DesignNetDocument::open( QString *errorString, const QString &fileName, const QString &realFileName )
{
d->space->setObjectName(realFileName);
Utils::XmlDeserializer deserializer(realFileName);
deserializer.deserialize("DesignNetSpace", *(d->space));
emit deserialized(deserializer);
return IDocument::open(errorString, fileName, realFileName);
}
DependenciesJob::DependenciesJob(const std::shared_ptr<QueryMessage> &query, const std::shared_ptr<Project> &project)
: QueryJob(query, project, QuietJob)
{
Deserializer deserializer(query->query());
Path path;
deserializer >> path >> mArgs;
mFileId = Location::fileId(path);
}
Packet::Packet(string packetData){
// Parse the packet into the object
stringstream deserializer(packetData);
string type;
deserializer >> type;
string d;
string t;
string dateTime;
deserializer >> d;
deserializer >> t;
stringstream dateTimeStream;
dateTimeStream << d << " " << t;
dateTime = dateTimeStream.str();
const char * timeBuffer =dateTime.c_str();
tm date;
strptime(timeBuffer, "%Y-%m-%d %H:%M:%S", &date);
time_t packetTime = mktime(&date);
setTimeSent(packetTime);
int life;
deserializer >> life;
setLifeTime(life);
int pno;
deserializer >> pno;
setPacketNumber(pno);
int hop;
deserializer >> hop;
hop++;
setHopCount(hop);
string src;
deserializer >> src;
setSourceAddress(src);
string dest;
deserializer >> dest;
setDestinationAddress(dest);
stringstream payloadStream;
payloadStream << deserializer.rdbuf();
string pay = payloadStream.str();
pay = pay.substr(1, pay.length());
setPayload(pay);
}
int main() {
int tree_arr[] = {4, 2, 7, 1, 3, 6, 9};
int len = sizeof(tree_arr)/sizeof(int);
struct TreeNode *root = deserializer(tree_arr, len);
visualize(root, len);
root = invertTree(root);
visualize(root, len);
int tree_arr2[] = {};
int len2 = sizeof(tree_arr2)/sizeof(int);
struct TreeNode *root2 = deserializer(tree_arr2, len2);
visualize(root2, len);
return 0;
}
const u8* CGameSetupMessage::Deserialize(const u8* pStart, const u8* pEnd)
{
// TODO: ought to handle serialization exceptions
const u8* pos = CNetMessage::Deserialize(pStart, pEnd);
std::istringstream stream(std::string(pos, pEnd));
CStdDeserializer deserializer(m_ScriptInterface, stream);
deserializer.ScriptVal("command", const_cast<JS::PersistentRootedValue*>(&m_Data));
return pEnd;
}
T serializationOfType(T inValue) {
std::string filename = SERIALITION_FILE_NAME;
IvwSerializer serializer(filename);
serializer.serialize("serializedValue", inValue);
serializer.writeFile();
IvwDeserializer deserializer(filename);
T outValue;
deserializer.deserialize("serializedValue", outValue);
return outValue;
}
void
YCbCrDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
nsIntRegion* aRegion,
nsIntPoint* aOffset)
{
if (!mGL) {
return;
}
NS_ASSERTION(aImage.type() == SurfaceDescriptor::TYCbCrImage, "SurfaceDescriptor mismatch");
YCbCrImageDataDeserializer deserializer(aImage.get_YCbCrImage().data().get<uint8_t>());
gfxIntSize gfxSize = deserializer.GetYSize();
gfxIntSize gfxCbCrSize = deserializer.GetCbCrSize();
if (!mYTexture->mTexImage || mYTexture->mTexImage->GetSize() != gfxSize) {
mYTexture->mTexImage = CreateBasicTextureImage(mGL,
gfxSize,
gfxASurface::CONTENT_ALPHA,
WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
FlagsToGLFlags(mFlags));
}
if (!mCbTexture->mTexImage || mCbTexture->mTexImage->GetSize() != gfxCbCrSize) {
mCbTexture->mTexImage = CreateBasicTextureImage(mGL,
gfxCbCrSize,
gfxASurface::CONTENT_ALPHA,
WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
FlagsToGLFlags(mFlags));
}
if (!mCrTexture->mTexImage || mCrTexture->mTexImage->GetSize() != gfxCbCrSize) {
mCrTexture->mTexImage = CreateBasicTextureImage(mGL,
gfxCbCrSize,
gfxASurface::CONTENT_ALPHA,
WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
FlagsToGLFlags(mFlags));
}
RefPtr<gfxImageSurface> tempY = new gfxImageSurface(deserializer.GetYData(),
gfxSize, deserializer.GetYStride(),
gfxASurface::ImageFormatA8);
RefPtr<gfxImageSurface> tempCb = new gfxImageSurface(deserializer.GetCbData(),
gfxCbCrSize, deserializer.GetCbCrStride(),
gfxASurface::ImageFormatA8);
RefPtr<gfxImageSurface> tempCr = new gfxImageSurface(deserializer.GetCrData(),
gfxCbCrSize, deserializer.GetCbCrStride(),
gfxASurface::ImageFormatA8);
nsIntRegion yRegion(nsIntRect(0, 0, gfxSize.width, gfxSize.height));
nsIntRegion cbCrRegion(nsIntRect(0, 0, gfxCbCrSize.width, gfxCbCrSize.height));
mYTexture->mTexImage->DirectUpdate(tempY, yRegion);
mCbTexture->mTexImage->DirectUpdate(tempCb, cbCrRegion);
mCrTexture->mTexImage->DirectUpdate(tempCr, cbCrRegion);
}
uint32_t VulkanWrapper::VWTextureGroupIndex::Deserialize(std::vector<unsigned char>& _data, uint32_t _index)
{
// The deserializer object
Serialize::Deserializer deserializer(_data, _index);
// Unpack the initial data
deserializer.UnpackData(m_ResourcePath.GetString(), Packet::PacketString::MaxStringSize);
deserializer.UnpackData(m_Identifier);
return deserializer.GetIndex();
}
SirenObject DeserializeLua(LuaState& state, const ISirenType& type)
{
SirenObject obj;
SirenLuaReader reader(state.GetState());
SirenObjectDeserializer deserializer(reader);
if (deserializer.Deserialize(obj, type))
{
return obj;
}
return SirenObject::Null;
}
void test_write_virtual_workbook()
{
xlnt::workbook old_wb, new_wb;
xlnt::excel_serializer serializer(old_wb);
std::vector<std::uint8_t> wb_bytes;
serializer.save_virtual_workbook(wb_bytes);
xlnt::excel_serializer deserializer(new_wb);
deserializer.load_virtual_workbook(wb_bytes);
TS_ASSERT(new_wb != nullptr);
}
optional<InnerConfig> InnerConfig::deserialize(const Data &data) {
Deserializer deserializer(&data);
try {
_checkHeader(&deserializer);
string cipherName = deserializer.readString();
auto result = deserializer.readTailData();
deserializer.finished();
return InnerConfig {cipherName, std::move(result)};
} catch (const exception &e) {
LOG(ERROR) << "Error deserializing inner configuration: " << e.what();
return none; // This can be caused by invalid input data and does not have to be a programming error. Don't throw exception.
}
}
const u8* CSimulationMessage::Deserialize(const u8* pStart, const u8* pEnd)
{
// TODO: ought to handle serialization exceptions
// TODO: ought to represent common commands more efficiently
const u8* pos = CNetMessage::Deserialize(pStart, pEnd);
std::istringstream stream(std::string(pos, pEnd));
CStdDeserializer deserializer(*m_ScriptInterface, stream);
deserializer.NumberU32_Unbounded("client", m_Client);
deserializer.NumberI32_Unbounded("player", m_Player);
deserializer.NumberU32_Unbounded("turn", m_Turn);
deserializer.ScriptVal("command", &m_Data);
return pEnd;
}
TEST(SaveableOperators, VectorOperatorsEmpty)
{
kv::FastSerializer serializer(1);
QVector<qint32> vector;
EXPECT_EQ(Hash(vector), 0);
serializer << vector;
kv::FastDeserializer deserializer(serializer.GetData(), serializer.GetIndex());
QVector<qint32> other_vector;
deserializer >> other_vector;
EXPECT_TRUE(other_vector.isEmpty());
EXPECT_EQ(Hash(other_vector), Hash(vector));
}
TEST(SaveableOperators, MapOperatorsEmpty)
{
kv::FastSerializer serializer(1);
QMap<qint32, qint32> map;
EXPECT_EQ(Hash(map), 0);
serializer << map;
kv::FastDeserializer deserializer(serializer.GetData(), serializer.GetIndex());
QMap<qint32, qint32> other_map;
deserializer >> other_map;
EXPECT_TRUE(other_map.isEmpty());
EXPECT_EQ(Hash(other_map), Hash(map));
}
TEST(SaveableOperators, PairOperators)
{
kv::FastSerializer serializer(1);
QPair<qint32, qint32> pair{11, 12};
EXPECT_EQ(Hash(pair), 23);
serializer << pair;
kv::FastDeserializer deserializer(serializer.GetData(), serializer.GetIndex());
QPair<qint32, qint32> other_pair;
deserializer >> other_pair;
EXPECT_EQ(other_pair.first, 11);
EXPECT_EQ(other_pair.second, 12);
EXPECT_EQ(Hash(other_pair), Hash(pair));
}
void *sockets_recvSerialized(t_socket_client *client, void *(*deserializer)(t_socket_sbuffer*)){
t_socket_buffer *buffer = sockets_recv(client);
void *data = NULL;
if( buffer != NULL ){
t_socket_sbuffer sbuffer;
sbuffer.size = buffer->size;
sbuffer.serializated_data = malloc(buffer->size);
memcpy(sbuffer.serializated_data, buffer->data, buffer->size);
data = deserializer(&sbuffer);
free(sbuffer.serializated_data);
free(buffer);
}
return data;
}
void
BufferTextureHost::InitSize()
{
if (mFormat == gfx::SurfaceFormat::YUV) {
YCbCrImageDataDeserializer yuvDeserializer(GetBuffer(), GetBufferSize());
if (yuvDeserializer.IsValid()) {
mSize = yuvDeserializer.GetYSize();
}
} else if (mFormat != gfx::SurfaceFormat::UNKNOWN) {
ImageDataDeserializer deserializer(GetBuffer(), GetBufferSize());
if (deserializer.IsValid()) {
mSize = deserializer.GetSize();
}
}
}
void testBinarySerializer() {
Data originalData;
originalData.key = 100;
for (int i = 11; i < 20; ++i) {
originalData.array.push_back(i);
}
BinarySerializer serializer;
serializer << originalData;
BinarySerializer deserializer((const char *) serializer.data(), serializer.size());
Data targetData;
deserializer >> targetData;
checkEqualData(originalData, targetData);
}
bool ModelDefinition::LoadFromNativeFile(const String &absolutePathIn)
{
// When loading from a native file, all we need to do is deserialize.
bool successful = false;
drfs_file* pFile;
if (drfs_open(g_Context->GetVFS(), absolutePathIn.c_str(), DRFS_READ, &pFile) == drfs_success)
{
FileDeserializer deserializer(pFile);
successful = this->Deserialize(deserializer);
drfs_close(pFile);
}
return successful;
}
unique_ptr<SpanTree> AnnotationDeserializer::readSpanTree() {
VespaDocumentDeserializer deserializer(_repo, _stream, _version);
StringFieldValue tree_name;
deserializer.read(tree_name);
_nodes.clear();
SpanNode::UP root = readSpanNode();
unique_ptr<SpanTree> span_tree(new SpanTree(tree_name.getValue(), std::move(root)));
uint32_t annotation_count = getInt1_2_4Bytes(_stream);
span_tree->reserveAnnotations(annotation_count);
for (uint32_t i = 0; i < annotation_count; ++i) {
readAnnotation(span_tree->annotation(i));
}
return span_tree;
}
void ExtensionListDialog::install()
{
static QByteArray state;
QFileDialog dlg(this);
dlg.setFileMode(QFileDialog::ExistingFiles);
dlg.setAcceptMode(QFileDialog::AcceptOpen);
dlg.setDefaultSuffix("*.aeb");
dlg.setConfirmOverwrite(false);
dlg.setReadOnly(true);
dlg.setResolveSymlinks(true);
dlg.setFilters(QStringList() << "Extension Bundles (*.aeb)" << "Extension Metadata (install.rdf)" << "All Files (*)");
dlg.setWindowTitle("Select extensions");
dlg.restoreState(state);
if (dlg.exec() == QDialog::Rejected)
{
return;
}
state = dlg.saveState();
QStringList filenames = dlg.selectedFiles();
AebListResource extensionRes; //manage lifetime of Aeb*'s that are allocated on the heap
QList<Aeb*> extensions;
foreach (QString filename, filenames)
{
extensionRes.push_back(new Aeb()); //take ownership
AebIo deserializer(*extensionRes.back());
std::string errMsg;
if (!deserializer.fromFile(filename.toStdString(), errMsg))
{
QMessageBox::critical(Service<DesktopServices>()->getMainWidget(), "Extension Error",
"Invalid extension bundle: " + filename + ".\n" + QString::fromStdString(errMsg));
}
else
{
if (!extensionRes.back()->checkTargetApplication(errMsg))
{
QMessageBox::critical(Service<DesktopServices>()->getMainWidget(), "Extension Error",
"Invalid extension bundle: " + QString::fromStdString(extensionRes.back()->getName()) + ".\n" + QString::fromStdString(errMsg));
}
else
{
extensions.push_back(extensionRes.back());
}
}
}
