void Sector::write(lisp::Writer& writer) { writer.write_string("name", name); writer.write_float("gravity", gravity); writer.write_string("music", music); // write spawnpoints for(SpawnPoints::iterator i = spawnpoints.begin(); i != spawnpoints.end(); ++i) { SpawnPoint* spawn = *i; writer.start_list("spawn-points"); writer.write_string("name", spawn->name); writer.write_float("x", spawn->pos.x); writer.write_float("y", spawn->pos.y); writer.end_list("spawn-points"); } // write objects for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end(); ++i) { Serializable* serializable = dynamic_cast<Serializable*> (*i); if(serializable) serializable->write(writer); } }
void ESEnumerableModifyWnd::SetEnumerableObject(EnumerableObject<Serializable>* pEnumerable){ ASSERT(pEnumerable); if( !pEnumerable ) return; ESChildControlList* pList = (ESChildControlList*)GetChildControl(1000); if( pList ){ Serializable* pObject = pEnumerable->CreateSerializableObject(); ASSERT(pObject); VariableInfo* pInfo = pObject->GetThisInfo(); MercuryGUI* pGUI = MercuryGUI::GetInstance(); _Size szText(0, 0); _string sTitle; int nLoop = 1; while( pInfo[nLoop].m_sAttributeName.length() > 0 ){ if( !pInfo[nLoop].m_bComplexType ){ sTitle = pInfo[nLoop].m_sDbFieldName; pGUI->header.m_fontItemText.GetTextSize(&sTitle, szText); if( szText.cx <= 0 ) szText.cx = 80; pList->AddColumn(pInfo[nLoop].m_sDbFieldName, pInfo[nLoop].m_sAttributeName, HAlignment::HAlignement_Left, szText.cx + 5, szText.cx + 5); szText.cx = 0; } nLoop ++; } VirtualRowSet* pRowSet = Serializable::SerializableObjectToVRowSet(pEnumerable); m_pListRowSet = pRowSet; m_pEnumerable = pEnumerable; pList->SetRowSet(pRowSet, true, true); delete pObject; } }
void test() { Deserializer::d()["TestSerializable"] = TestSerializable::returnNew; TestSerializable testSerializable("important stuff"); ptree serial = testSerializable.serialize(); stringstream ss; write_xml(ss, serial); cout << "TestSerializable.serialize() to string:" << endl << ss.str() << endl; Serializable * deserializedUncast = newDeserialize(serial); //Serializable * deserializedUncast = Deserializer::d()["TestSerializable"](); ptree serial2 = deserializedUncast->serialize(); stringstream ss2; write_xml(ss2, serial2); cout << "deserializedUncast->serialize() *post-returned* to string:" << endl << ss2.str() << endl; TestSerializable * deserialized = dynamic_cast<TestSerializable *>(deserializedUncast); cout << "deserialized->data: " << deserialized->data << endl; }
Serializable * newDeserialize(ptree serial) { #if VERBOSE cout << "registered types:" << endl; for(map<string, Serializable * (*)()>::iterator iterator = Deserializer::d().begin(); iterator != Deserializer::d().end(); iterator++) { cout << iterator->first << endl; } #endif string type = serial.get<std::string>("type"); map<string, Serializable * (*)()>::iterator it = Deserializer::d().find(type); if(it != Deserializer::d().end()) { Serializable * toReturn = Deserializer::d()[type](); toReturn->deserialize(serial); #if VERBOSE stringstream ss2; write_xml(ss2, toReturn->serialize()); cout << "newDeserialize()->serialize() *pre-returned* to string:" << endl << ss2.str() << endl; #endif return toReturn; } else { cout<<"ERROR! No compatible deserialization function for " << type; //In case someone forgets to add a deserializer throw 319; } }
void Pololu::Usc::Usb::SetSpeed::read(std::istream& stream) { Serializable<unsigned char> servo; Serializable<unsigned short> value; setServo(servo.read(stream)); setValue(value.read(stream)); }
RobotConfiguration* readLog(std::vector<BaseSensorData*>& sensorDatas, Deserializer& des){ RobotConfiguration* conf = 0; Serializable *o; int numObjects=0; while( (! conf && (o=des.readObject())) ){ cerr << o->className() << endl; numObjects++; if (! conf) { conf = dynamic_cast<RobotConfiguration*>(o); if (conf) { cerr << "got config" << endl; if (! conf->isReady()){ cerr << "conf failure" << endl; return 0; } } continue; } } if (!conf) { cerr << "unable to read robot configuration, aborting" << endl; return 0; } while( (o=des.readObject()) ){ BaseSensorData* sensorData=dynamic_cast<BaseSensorData*>(o); if(sensorData) sensorDatas.push_back(sensorData); } return conf; }
void init(bool deserialize) { LOG(debug) << "global.min_gamma_shape=" << options.get<double>("global.min_gamma_shape"); layer_size = options.get<int>("layer.size"); lf = get_link_function(options.get<string>("lf")); min_gamma_sample = options.get<double>("global.min_gamma_sample"); wshape.set_size(layer_size, n_examples); wscale.set_size(layer_size, n_examples); ScoreFunction score_shape = [=](double z, arma::uword i, arma::uword j) { auto shape0 = wshape(i,j); auto shape = lf->f(shape0); auto scale = lf->f(wscale(i,j)); return lf->g(shape0) * (- gsl_sf_psi(shape) - log(scale) + log(z)); }; register_param(&wshape, score_shape, deserialize); ScoreFunction score_scale = [=](double z, arma::uword i, arma::uword j) { auto shape = lf->f(wshape(i,j)); auto scale0 = wscale(i,j); auto scale = lf->f(scale0); return lf->g(scale0) * (- shape/scale + z/scale/scale); }; register_param(&wscale, score_scale, deserialize); }
Serializable *Serializable::DeserializeNew (shared_ptr <Stream> stream) { string name = Serializable::DeserializeHeader (stream); Serializable *serializable = SerializerFactory::GetNewSerializable (name); serializable->Deserialize (stream); return serializable; }
virtual void truncate(const ExampleIds& example_ids) { auto min_shape0 = lf->f_inv(options.get<double>("global.min_gamma_shape")); auto min_scale0 = lf->f_inv(options.get<double>("global.min_gamma_scale")); for(auto j : example_ids) { wshape.col(j).transform([=](double v) { return max(v, min_shape0); }); wscale.col(j).transform([=](double v) { return max(v, min_scale0); }); } }
bool OutXmlSerializer::save(Stream& stream) { XmlDocument doc; XmlDeclaration* decl = zenic_new XmlDeclaration; decl->setValue("xml"); decl->setAttribute("version","1.0"); decl->setAttribute("encoding","ISO-8859-1"); doc.addChild(decl); XmlComment* comment = new XmlComment; comment->setValue(" Cell XML Object Graph "); doc.addChild(comment); // add initial objects for (uint i = 0, n = count(); i < n; ++i) { Serializable* initial = (*this)[i]; uint j,m; for (j = 0, m = m_objects.count(); j < m; ++j) { if (m_objects[j] == initial) break; } if (j == m_objects.count()) m_objects.pushBack(initial); } // build xml tree XmlElement* root = new XmlElement; root->setValue("zenic"); for (uint i = 0; i < m_objects.count(); ++i) { Serializable* object = m_objects[i]; ZENIC_ASSERT(object); m_current = 0; m_currentIndex = i; object->serialize(*this); ZENIC_ASSERT(m_current); root->addChild(m_current); } doc.addChild(root); // write tree to stream if (!doc.save(stream)) return false; return true; }
void Database::Statement::write(const Serializable &s) { if(mOutputLevel == 0 || s.isInlineSerializable()) s.serialize(*this); else { String tmp; JsonSerializer serializer(&tmp); s.serialize(serializer); write(tmp); } }
bool Database::Statement::read(Serializable &s) { if(mInputLevel == 0 || s.isInlineSerializable()) return s.deserialize(*this); else { String tmp; if(!read(tmp)) return false; JsonSerializer serializer(&tmp); s.deserialize(serializer); return true; } }
bool JsonSerializer::input(Serializable &s) { if(s.isInlineSerializable() && !s.isNativeSerializable()) { String str; if(!input(str)) return false; s.fromString(str); return true; } else return s.deserialize(*this); }
void SerializedInstanceTest::testSerialized(){ toTest->addSerializable( getTestSerializable() ); Serializable *returned = toTest->getSerializable(); CPPUNIT_ASSERT( returned != 0 ); CPPUNIT_ASSERT( returned->getDataType() == getTestSerializable()->getDataType() ); delete returned; }
void BlinkM::ScriptLine::read(std::istream& stream) { Serializable<unsigned char> durationTicks; Serializable<std::string> typeName; this->durationTicks = durationTicks.read(stream); typeName.read(stream); request = Singleton<Protocol>::getInstance().createRequest( typeName.read(stream)); request->read(stream); }
bool RangeProfilePlotManager::deserialize(SessionItemDeserializer& deserializer) { XmlReader reader(NULL, false); DOMElement* pRootElement = deserializer.deserialize(reader, "RangeProfilePlotManager"); if (pRootElement) { std::string viewId = A(pRootElement->getAttribute(X("viewId"))); mpView = dynamic_cast<PlotView*>(Service<SessionManager>()->getSessionItem(viewId)); mpPlot = Service<DesktopServices>()->createPlotWidget(getName(), CARTESIAN_PLOT); VERIFY(mpPlot); Serializable* pPlotSer = dynamic_cast<Serializable*>(mpPlot); // The imp side is serializable VERIFY(pPlotSer); if (!pPlotSer->fromXml(findChildNode(pRootElement, "plot"), reader.VERSION)) { return false; } mpView = mpPlot->getPlot(); VERIFY(mpView); Serializable* pPlotViewSer = dynamic_cast<Serializable*>(mpView); // The imp side is serializable VERIFY(pPlotViewSer); if (!pPlotViewSer->fromXml(findChildNode(pRootElement, "plotView"), reader.VERSION)) { return false; } std::list<PlotObject*> objects; mpView->getObjects(POINT_SET, objects); FOR_EACH_DOMNODE(pRootElement, pChild) { if (XMLString::equals(pChild->getNodeName(), X("signature"))) { DOMElement* pChldElmnt = static_cast<DOMElement*>(pChild); std::string sigId = A(pChldElmnt->getAttribute(X("sigId"))); std::string pointSetName = A(pChldElmnt->getAttribute(X("pointSetName"))); Signature* pSignature = static_cast<Signature*>(Service<SessionManager>()->getSessionItem(sigId)); if (pSignature == NULL) { return false; } mSigPointSets[pSignature] = pointSetName; pSignature->attach(SIGNAL_NAME(Subject, Deleted), Slot(this, &RangeProfilePlotManager::signatureDeleted)); pSignature->getDataDescriptor()->attach(SIGNAL_NAME(DataDescriptor, Renamed), Slot(this, &RangeProfilePlotManager::signatureRenamed)); } } deserializer.nextBlock(); return DockWindowShell::deserialize(deserializer); } return false; }
boost::shared_ptr<Serializable <PDXRecord> > PDXFileReader<FileEnumeratorType>::read() { using namespace std; using namespace boost; Serializable <PDXRecord>* newRecord; // open the next file to read. if (!curFile.is_open()) { if (this->fIt == this->fEnum.end()) { // Don't bother, no more files. return shared_ptr<Serializable <PDXRecord> >(); } const char* filename = (this->fIt)->file_string().c_str(); curFile.open(filename, ios::in | ios::binary); if (curFile.fail()) { this->_error = true; this->_errorMsg = string(" Failed to open file ") + filename; return shared_ptr<Serializable <PDXRecord> >(); } arl_file_hdr_t header; curFile.read((char*) (&header), sizeof (arl_file_hdr_t)); header.base_date = ntohl(header.base_date); this->base_time.set(header.base_date, 0); this->fIt++; } //do the reading. newRecord = new PDXRecord(&(this->base_time)); char record[sizeof (pidx_data_t)]; string dataStr; curFile.read(record, sizeof (record)); if (curFile.eof()) { curFile.close(); return this->read(); } else { newRecord->unserialize(dataStr.insert(0, record, sizeof (record))); } return shared_ptr<Serializable <PDXRecord> >(newRecord); }
// // read_network_attributes // void ClientSidePrediction::read_network_attributes(Serializable& object, Deserializer& source) { const auto attributes = object.GetNetworkAttributes(); if (!attributes) return; unsigned numAttributes = attributes->Size(); for (unsigned i = 0; i < numAttributes && !source.IsEof(); ++i) { const auto& attr = attributes->At(i); object.OnSetAttribute(attr, source.ReadVariant(attr.type_)); } }
void Deserializer::deserialize(const std::string& key, Serializable& sObj) { try { NodeSwitch ns(*this, key); sObj.deserialize(*this); } catch (TxException&) { } }
void Html::object(const Serializable &s) { // TODO open("span"); mStream->write(escape(s.toString())); close("span"); }
// // write_network_attributes // void ClientSidePrediction::write_network_attributes(Serializable& object, Serializer& dest) { const auto attributes = object.GetNetworkAttributes(); if (!attributes) return; auto numAttributes = attributes->Size(); Variant value; for (unsigned i = 0; i < numAttributes; ++i) { const auto& attr = attributes->At(i); value.Clear(); object.OnGetAttribute(attr, value); dest.WriteVariantData(value); } }
bool RangeProfilePlotManager::serialize(SessionItemSerializer& serializer) const { XMLWriter writer("RangeProfilePlotManager"); writer.addAttr("viewId", mpView->getId()); #pragma message(__FILE__ "(" STRING(__LINE__) ") : warning : We should be able to save the plot's session id and restore " \ "using that but the PlotWidget is not really part of the session. The following code is a work around and should be changed " \ "when OPTICKS-542 is implemented. (tclarke)") writer.pushAddPoint(writer.addElement("plot")); Serializable* pPlotSer = dynamic_cast<Serializable*>(mpPlot); // The imp side is serializable VERIFY(pPlotSer); if (!pPlotSer->toXml(&writer)) { return false; } writer.popAddPoint(); writer.pushAddPoint(writer.addElement("plotView")); Serializable* pPlotViewSer = dynamic_cast<Serializable*>(mpView); // The imp side is serializable VERIFY(pPlotViewSer); if (!pPlotViewSer->toXml(&writer)) { return false; } writer.popAddPoint(); for (std::map<Signature*, std::string>::const_iterator sig = mSigPointSets.begin(); sig != mSigPointSets.end(); ++sig) { writer.pushAddPoint(writer.addElement("signature")); writer.addAttr("sigId", sig->first->getId()); writer.addAttr("pointSetName", sig->second); writer.popAddPoint(); } if (!serializer.serialize(writer)) { return false; } serializer.endBlock(); return DockWindowShell::serialize(serializer); }
bool Serializer::writeObject(Serializable& instance) { ObjectData* data=new ObjectData(); instance.serialize(*data,*this); processDataForWrite(data,*this); if (!_datastream) { string str=_dataFileName; replaceEnvTags(str,_envMap); create_directories(path(str).parent_path()); _datastream=new ofstream(str.c_str()); } if (*_datastream) { _objectWriter->writeObject(*_datastream,instance.className(),*data); //TODO Change writer to get status flag return true; } return false; }
void SerializedInstanceTest::testComplex2(){ const int myInt = 1264; const unsigned int myUnsigned = 172; const string myString = "always estimate the power of denial"; toTest->addInt( myInt ); toTest->addString( myString ); toTest->addSerializable( getTestSerializable() ); toTest->addUnsigned( myUnsigned ); CPPUNIT_ASSERT( myInt == toTest->getInt() ); CPPUNIT_ASSERT( myString == toTest->getString() ); Serializable *returned = toTest->getSerializable(); CPPUNIT_ASSERT( returned != 0 ); CPPUNIT_ASSERT( getTestSerializable()->getDataType() == returned->getDataType() ); delete returned; CPPUNIT_ASSERT( myUnsigned == toTest->getUnsigned() ); }
Serializable *const Deserializer::Read(std::istream &stream) { Serializable *pSerializable = 0; BEGIN_CODE_BLOCK { // Read the first Object's type std::string objectType; if( !ParseVariable( stream, "begin", objectType ) ) break; // Create the object pSerializable = ObjectFactory<Serializable>::Create( objectType ); if( !pSerializable ) { std::cout << "Error: Unknown Object found: " << objectType << std::endl; EXIT_CODE_BLOCK; } // Load the object if( !pSerializable->Read( stream ) ) { SAFE_DELETE_SCALAR( pSerializable ); EXIT_CODE_BLOCK; } // Restore all pointers if( !RestoreAllPointers() ) { SAFE_DELETE_SCALAR( pSerializable ); EXIT_CODE_BLOCK; } } END_CODE_BLOCK; return pSerializable; }
Buffer::Pointer Buffer::write( const Serializable &object ) { Buffer::Pointer thisptr = shared_from_this(); object.save(thisptr); return thisptr; }
void SerializerStream::full_serialization(const Serializable &obj, bool include_typehashes){ auto node = obj.get_object_node(); #ifdef LOG std::clog << "Traversing reference graph...\n"; #endif std::set<std::uint32_t> used_types; objectid_t root_object = 0; { std::vector<decltype(node)> stack, temp_stack; this->id_map[0] = 0; auto id = this->save_object(node.get_address()); assert(id); root_object = id; this->node_map[id] = node; used_types.insert(node.get_typeid()); stack.push_back(node); while (stack.size()){ auto top = stack.back(); stack.pop_back(); if (!top.get_address()) continue; top.get_children(temp_stack); for (auto &i : temp_stack){ id = this->save_object(i.get_address()); if (!id) continue; this->node_map[id] = i; used_types.insert(i.get_typeid()); stack.push_back(i); } temp_stack.clear(); } } if (include_typehashes){ #ifdef LOG std::clog << "Travesal found " << this->node_map.size() << " objects.\n" "Serializing type hashes...\n"; #endif auto list = obj.get_metadata()->get_known_types(); std::map<decltype(list[0].first), decltype(list[0].second) *> typemap; for (auto &i : list) typemap[i.first] = &i.second; this->serialize((std::uint32_t)used_types.size()); for (auto &t : used_types){ this->serialize(t); this->serialize_array(typemap[t]->digest); } } #ifdef LOG std::clog << "Remapping object IDs...\n"; #endif { std::map<std::uint32_t, std::vector<objectid_t>> remap; for (auto &n : this->node_map) remap[n.second.get_typeid()].push_back(n.first); this->next_object_id = 1; decltype(this->node_map) temp; bool root_set = false; this->id_map.clear(); this->id_map[0] = 0; for (auto &r : remap){ for (auto i : r.second){ auto &node = this->node_map[i]; if (!node.get_address()) continue; auto oid = this->save_object(node.get_address()); if (!root_set && i == root_object){ root_object = oid; root_set = true; } temp[oid] = node; } } this->node_map = temp; } #ifdef LOG std::clog << "Serializing node map...\n"; #endif { std::vector<std::pair<std::uint32_t, objectid_t>> type_map; for (auto &n : this->node_map){ auto type = n.second.get_typeid(); if (!type) throw InternalErrorException(); if (!type_map.size() || type != type_map.back().first){ type_map.push_back(std::make_pair(type, n.first)); continue; } type_map.back().second = std::max(type_map.back().second, n.first); } this->serialize((wire_size_t)type_map.size()); for (auto &i : type_map){ this->serialize(i.first); this->serialize(i.second); } this->serialize(root_object); } #ifdef LOG std::clog << "Serializing nodes...\n"; #endif for (auto &n : this->node_map) n.second.serialize(*this); #ifdef LOG std::clog << "Serialization done!\n"; #endif }
bool BinaryFileStream::Save(const Serializable & val) { val.Serialize(*this); return true; }
void Serializer::serialize(const std::string& key, const Serializable& sObj) { auto newNode = util::make_unique<TxElement>(key); rootElement_->LinkEndChild(newNode.get()); NodeSwitch nodeSwitch(*this, newNode.get()); sObj.serialize(*this); }
void Pololu::Usc::Usb::RestartScriptAt::read(std::istream& stream) { Serializable<unsigned char> subroutine; setSubroutine(subroutine.read(stream)); }