/* saves the state of the rom settings */ void BankHeistSettings::saveState(Serializer & ser) { ser.putInt(m_reward); ser.putInt(m_score); ser.putBool(m_terminal); ser.putInt(m_lives); }
//************************************************************************************ //************************************************************************************ void AxisymUpdatedLagrangianElement::save( Serializer& rSerializer ) const { KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, LargeDisplacementElement ) rSerializer.save("DeformationGradientF0",mDeformationGradientF0); rSerializer.save("DeterminantF0",mDeterminantF0); }
/* saves the state of the rom settings */ void SpaceInvadersSettings::saveState(Serializer & ser) { ser.putInt(m_reward); ser.putInt(m_score); ser.putBool(m_terminal); }
void GetHostDevicesRequest::Serialize (shared_ptr <Stream> stream) const { CoreServiceRequest::Serialize (stream); Serializer sr (stream); sr.Serialize ("PathListOnly", PathListOnly); }
void AnimationController::Track::serialize(Serializer& s) { s.descriptor(SERIALIZER_NAME("data")) << data; s.descriptor(SERIALIZER_NAME("type")) << type; s.descriptor(SERIALIZER_NAME("compression")) << type; }
// DAVID: would you rather duplicate this code or keep the lock longer? Transaction::pointer Transaction::transactionFromSQL (const std::string& sql) { Serializer rawTxn; std::string status; uint32 inLedger; int txSize = 2048; rawTxn.resize (txSize); { DeprecatedScopedLock sl (getApp().getTxnDB ()->getDBLock ()); Database* db = getApp().getTxnDB ()->getDB (); if (!db->executeSQL (sql, true) || !db->startIterRows ()) return Transaction::pointer (); db->getStr ("Status", status); inLedger = db->getInt ("LedgerSeq"); txSize = db->getBinary ("RawTxn", &*rawTxn.begin (), rawTxn.getLength ()); if (txSize > rawTxn.getLength ()) { rawTxn.resize (txSize); db->getBinary ("RawTxn", &*rawTxn.begin (), rawTxn.getLength ()); } db->endIterRows (); } rawTxn.resize (txSize); SerializerIterator it (rawTxn); SerializedTransaction::pointer txn = boost::make_shared<SerializedTransaction> (boost::ref (it)); Transaction::pointer tr = boost::make_shared<Transaction> (txn, true); TransStatus st (INVALID); switch (status[0]) { case TXN_SQL_NEW: st = NEW; break; case TXN_SQL_CONFLICT: st = CONFLICTED; break; case TXN_SQL_HELD: st = HELD; break; case TXN_SQL_VALIDATED: st = COMMITTED; break; case TXN_SQL_INCLUDED: st = INCLUDED; break; case TXN_SQL_UNKNOWN: break; default: assert (false); } tr->setStatus (st); tr->setLedger (inLedger); return tr; }
// GetDeviceSizeRequest void GetDeviceSizeRequest::Deserialize (shared_ptr <Stream> stream) { CoreServiceRequest::Deserialize (stream); Serializer sr (stream); Path = sr.DeserializeWString ("Path"); }
Blob STValidation::getSerialized () const { Serializer s; add (s); return s.peekData (); }
void Screen::synchronize(Serializer &s) { int fontNumb = _fontNumber; s.syncAsByte(fontNumb); if (s.isLoading()) setFont(fontNumb); }
PlayerInfo::PlayerInfo(Serializer& ser) : BasePlayerInfo(ser, false), isHost(ser.PopBool()), ping(ser.PopUnsignedInt()) {}
void PlayerInfo::Serialize(Serializer& ser) const { BasePlayerInfo::Serialize(ser, false); ser.PushBool(isHost); ser.PushUnsignedInt(ping); }
void UIElement::synchronize(Serializer &s) { BackgroundSceneObject::synchronize(s); s.syncAsSint16LE(_field88); s.syncAsSint16LE(_enabled); s.syncAsSint16LE(_frameNum); }
void UIInventoryScroll::synchronize(Serializer &s) { UIElement::synchronize(s); s.syncAsSint16LE(_isLeft); }
void UIInventorySlot::synchronize(Serializer &s) { UIElement::synchronize(s); s.syncAsSint16LE(_objIndex); SYNC_POINTER(_object); }
Serializer::Serializer(Serializer& s, bool allowReference) : SerializeBase(s.getFileName(), allowReference) { initialize(); }
void STVector256::add(Serializer& s) const { s.addVL(mValue.empty() ? NULL : mValue[0].begin(), mValue.size() * (256 / 8)); }
void APFloat::Emit(Serializer& S) const { S.Emit(convertToAPInt()); }
string Serializable::DeserializeHeader (shared_ptr <Stream> stream) { Serializer sr (stream); return sr.DeserializeString ("SerializableName"); }
int main (){ std::string db_name = "/home/ivanzjj/radix_tree"; RocksdbInstance::set_db_name (db_name); Ledger::pointer ledger = std::make_shared <Ledger> (); std::string db_name2 = "/home/ivanzjj/ledger.db"; SqliteInstance::set_db_name (db_name2); uint256 hash; char hash_ch[32]; for (int i=0;i<32;i++) hash_ch[i] = i; hash.init (hash_ch); hash.to_string (); Serializer ss; char ch[100]; for (int i=0;i<100;i++) ch[i] = i; ss.add_raw (ch, 100); if (!ledger->add_account_tree_entry (hash, ss)){ printf ("add_account_tree_entry error!\n"); return 1; } // dfs (ledger->get_account_tree ()->get_root (), 0); for (int i = 0; i < 32; i++){ hash_ch[i] = i; } hash_ch[0] = 1; hash.init (hash_ch); hash.to_string (); if (!ledger->add_account_tree_entry (hash, ss)){ printf ("add_account_tree_entry error2\n"); return 1; } // dfs (ledger->get_account_tree ()->get_root (), 0); for (int i = 0; i < 32; i++) hash_ch[i] = i; hash_ch[0] = 1; hash_ch[1] = 2; hash.init (hash_ch); hash.to_string (); if (!ledger->add_account_tree_entry (hash, ss)){ printf ("add_account_tree_entry error2\n"); return 1; } // dfs (ledger->get_account_tree ()->get_root (), 0); for (int i = 0; i < 32; i++){ hash_ch[i] = i; } hash.init (hash_ch); if (ledger->has_account (hash)){ hash.to_string (); printf ("YES\n"); ch[0] = 10; ss.peek_data ().clear(); ss.add_raw (ch, 100); RadixMerkleTreeLeaf::pointer new_item = std::make_shared<RadixMerkleTreeLeaf> (hash, ss); if (!ledger->update_account_tree_entry (new_item)){ printf ("update_account_tree_entry error!\n"); return 1; } } else { printf ("NO\n"); } // dfs (ledger->get_account_tree ()->get_root (), 0); return 0; }
void Serializable::SerializeHeader (Serializer &serializer, const string &name) { serializer.Serialize ("SerializableName", name); }
void GetDeviceSizeRequest::Serialize (shared_ptr <Stream> stream) const { CoreServiceRequest::Serialize (stream); Serializer sr (stream); sr.Serialize ("Path", wstring (Path)); }
// GetDeviceSizeResponse void GetDeviceSizeResponse::Deserialize (shared_ptr <Stream> stream) { Serializer sr (stream); sr.Deserialize ("Size", Size); }
/** * Serialises the given rect */ void Rect::synchronize(Serializer &s) { s.syncAsSint16LE(left); s.syncAsSint16LE(top); s.syncAsSint16LE(right); s.syncAsSint16LE(bottom); }
void GetDeviceSizeResponse::Serialize (shared_ptr <Stream> stream) const { Serializable::Serialize (stream); Serializer sr (stream); sr.Serialize ("Size", Size); }
/* saves the state of the rom settings */ void BowlingSettings::saveState(Serializer & ser) { ser.putInt(m_reward); ser.putInt(m_score); ser.putBool(m_terminal); }
void WallProjectile::Serialize(bool write, Serializer & data, Serializer * old){ Object::Serialize(write, data, old); data.Serialize(write, state_i, old); }
void AxisymUpdatedLagrangianElement::load( Serializer& rSerializer ) { KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, LargeDisplacementElement ) rSerializer.load("DeformationGradientF0",mDeformationGradientF0); rSerializer.load("DeterminantF0",mDeterminantF0); }
std::string JSON::Serialize(google::protobuf::Message const& message) { Serializer serializer; serializer.WriteMessage(message); return serializer.GetString(); }
bool Animation::Save(Serializer& dest) const { // Write ID, name and length dest.WriteFileID("UANI"); dest.WriteString(animationName_); dest.WriteFloat(length_); // Write tracks dest.WriteUInt(tracks_.Size()); for (HashMap<StringHash, AnimationTrack>::ConstIterator i = tracks_.Begin(); i != tracks_.End(); ++i) { const AnimationTrack& track = i->second_; dest.WriteString(track.name_); dest.WriteUByte(track.channelMask_); dest.WriteUInt(track.keyFrames_.Size()); // Write keyframes of the track for (unsigned j = 0; j < track.keyFrames_.Size(); ++j) { const AnimationKeyFrame& keyFrame = track.keyFrames_[j]; dest.WriteFloat(keyFrame.time_); if (track.channelMask_ & CHANNEL_POSITION) dest.WriteVector3(keyFrame.position_); if (track.channelMask_ & CHANNEL_ROTATION) dest.WriteQuaternion(keyFrame.rotation_); if (track.channelMask_ & CHANNEL_SCALE) dest.WriteVector3(keyFrame.scale_); } } // If triggers have been defined, write an XML file for them if (triggers_.Size()) { File* destFile = dynamic_cast<File*>(&dest); if (destFile) { String xmlName = ReplaceExtension(destFile->GetName(), ".xml"); SharedPtr<XMLFile> xml(new XMLFile(context_)); XMLElement rootElem = xml->CreateRoot("animation"); for (unsigned i = 0; i < triggers_.Size(); ++i) { XMLElement triggerElem = rootElem.CreateChild("trigger"); triggerElem.SetFloat("time", triggers_[i].time_); triggerElem.SetVariant(triggers_[i].data_); } File xmlFile(context_, xmlName, FILE_WRITE); xml->Save(xmlFile); } else URHO3D_LOGWARNING("Can not save animation trigger data when not saving into a file"); } return true; }
std::vector<unsigned char> SerializedValidation::getSigned() const { Serializer s; add(s); return s.peekData(); }