public static async Task Handle(Packet p, Presence pr) { var match = pr.CurrentMatch; if (match is null) { return; } var reader = new SerializationReader(new MemoryStream(p.Data)); var slotIndex = reader.ReadInt32(); if (match.InProgress || slotIndex > Match.MAX_PLAYERS || slotIndex < 0) { return; } var slot = match.Slots[slotIndex]; if ((slot.Status & SlotStatus.HasPlayer) > 0 || slot.Status == SlotStatus.Locked) { return; } var currentSlot = match.Slots.FirstOrDefault(x => x.Presence == pr); slot.CopyFrom(currentSlot); currentSlot.Clear(); foreach (var presence in match.Presences) { await presence.MatchUpdate(match); } }
/// <summary> /// Parses presence.db file. /// </summary> /// <param name="stream">Stream containing presence.db data.</param> /// <returns>A usable <see cref="PresenceDatabase"/>.</returns> public static PresenceDatabase DecodePresence(Stream stream) { PresenceDatabase db = new PresenceDatabase(); using (var r = new SerializationReader(stream)) { db.OsuVersion = r.ReadInt32(); int playersCount = r.ReadInt32(); for (int i = 0; i < playersCount; i++) { Player player = new Player(); player.UserId = r.ReadInt32(); player.Username = r.ReadString(); player.Timezone = r.ReadByte() - 24; player.CountryCode = r.ReadByte(); byte b = r.ReadByte(); player.Permissions = (Permissions)(b & ~0xe0); player.Ruleset = (Ruleset)Math.Max(0, Math.Min(3, ((b & 0xe0) >> 5))); player.Longitude = r.ReadSingle(); player.Latitude = r.ReadSingle(); player.Rank = r.ReadInt32(); player.LastUpdateTime = r.ReadDateTime(); db.Players.Add(player); } } return(db); }
internal Score(SerializationInfo info, StreamingContext ctxt) { SerializationReader sr = SerializationReader.GetReader(info); pass = true; fileChecksum = sr.ReadString(); playerName = sr.ReadString(); string scoreChecksumCheck = sr.ReadString(); count300 = sr.ReadUInt16(); count100 = sr.ReadUInt16(); count50 = sr.ReadUInt16(); countGeki = sr.ReadUInt16(); countKatu = sr.ReadUInt16(); countMiss = sr.ReadUInt16(); totalScore = sr.ReadInt32(); maxCombo = sr.ReadUInt16(); perfect = sr.ReadBoolean(); enabledMods = (Mods)sr.ReadInt32(); rawGraph = sr.ReadString(); rawReplayCompressed = sr.ReadByteArray(); date = sr.ReadDateTime(); if (scoreChecksumCheck != offlineScoreChecksum) { throw new Exception("f****d score"); } }
public void Load(SerializationReader reader, Fallen8 fallen8) { if (WriteResource()) { reader.ReadInt32();//parameter var keyCount = reader.ReadInt32(); _idx = new Dictionary <IComparable, AGraphElement>(keyCount); for (var i = 0; i < keyCount; i++) { var key = reader.ReadObject(); var graphElementId = reader.ReadInt32(); AGraphElement graphElement; if (fallen8.TryGetGraphElement(out graphElement, graphElementId)) { _idx.Add((IComparable)key, graphElement); } else { Logger.LogError(String.Format("[SingleValueIndex] Error while deserializing the index. Could not find the graph element \"{0}\"", graphElementId)); } } FinishWriteResource(); return; } throw new CollisionException(this); }
/// <summary> /// Parses collection.db file. /// </summary> /// <param name="stream">Stream containing collection.db data.</param> /// <returns>A usable <see cref="CollectionDatabase"/>.</returns> public static CollectionDatabase DecodeCollection(Stream stream) { CollectionDatabase db = new CollectionDatabase(); using (var r = new SerializationReader(stream)) { db.OsuVersion = r.ReadInt32(); int collectionsCount = r.ReadInt32(); db.CollectionCount = collectionsCount; for (int i = 0; i < collectionsCount; i++) { Collection collection = new Collection(); collection.Name = r.ReadString(); int count = r.ReadInt32(); collection.Count = count; for (int j = 0; j < count; j++) { collection.MD5Hashes.Add(r.ReadString()); } db.Collections.Add(collection); } } return(db); }
public static async Task Handle(Packet p, Presence pr) { var ms = new MemoryStream(p.Data); using var reader = new SerializationReader(ms); pr.Status = new () { Status = (ActionStatuses)reader.ReadByte(), StatusText = reader.ReadString(), BeatmapChecksum = reader.ReadString(), CurrentMods = (Mods)reader.ReadUInt32(), CurrentPlayMode = (PlayMode)reader.ReadByte(), BeatmapId = reader.ReadInt32() }; var lbMode = pr.Status.CurrentMods switch { var mod when(mod& Mods.Relax) > 0 => LeaderboardMode.Relax, _ => LeaderboardMode.Vanilla, }; // We just want to update our stats from cache, so we don't // use context here await pr.GetOrUpdateUserStats(null, lbMode, false); await pr.UserStats(); } }
public void ReadFromStream(SerializationReader r) { Sender = r.ReadString(); Message = r.ReadString(); Channel = r.ReadString(); SenderId = r.ReadInt32(); }
/// <exclude/> public FilterColumn(SerializationInfo serializationInfo, StreamingContext streamingContext) { if (SerializerHelper.UseFastSerialization) { using (SerializationReader reader = new SerializationReader((byte[])serializationInfo.GetValue("d", typeof(byte[])))) { _alias = reader.ReadString(); _columnId = reader.ReadString(); _compareOperator = reader.ReadString(); _logicalOperator = reader.ReadString(); } } else { if (SerializerHelper.FileVersionCurrent <= SerializerHelper.FileVersionLatest) { _alias = serializationInfo.GetString("Alias"); _column = (Column)serializationInfo.GetValue("Column", ModelTypes.Column); _compareOperator = serializationInfo.GetString("CompareOperator"); _logicalOperator = serializationInfo.GetString("LogicalOperator"); } else { throw new NotImplementedException(string.Format("FilterColumn deserialize does not handle version {0} yet.", SerializerHelper.FileVersionCurrent)); } } }
public virtual void Load(SerializationReader SR) { SR.ReadStartElement(); int version = SR.ReadVersion(); switch (version) { case 0: { Author = SR.ReadString(); Create = SR.ReadString(); Message = SR.ReadString(); SR.ReadStartElement(); int length = SR.ReadInt(); for (int i = 0; i < length; i++) { ForumMessage baseforum = SR.ReadType() as ForumMessage; if (baseforum != null) { baseforum.Load(SR); Add(baseforum); } } SR.ReadEndElement(); break; } } SR.ReadEndElement(); }
// Load data is called when loading the save game, we also need to override this public override void LoadData(SerializationReader Reader) { // Load our normal data base.LoadData(Reader); this.Recipes = new List <acegiak_PaintingRecipe>(); if (Reader == null) { throw new Exception("The Reader is null!"); } if (Recipes == null) { throw new Exception("The recipes list is null!"); } if (this == null) { throw new Exception("This is null!"); } // Read the number we wrote earlier telling us how many items there were int arraySize = Reader.ReadInt32(); for (int i = 0; i < arraySize; i++) { acegiak_PaintingRecipe.Read(Reader, this); // Similar to above, if we had a basic type in our list, we would instead use the Reader.Read function specific to our object type. } }
protected override void SetObjectData(SerializationReader sr) { base.SetObjectData(sr); sr.ReadInt32(); _Url = sr.ReadString(); }
public static PlayerPresence ReadFromReader(SerializationReader r) { var p = new PlayerPresence(); p.ReadFromStream(r); return(p); }
public override void Load(SerializationReader Reader) { base.Load(Reader); this.Stat = Reader.ReadString(); this.Amount = Reader.ReadSingle(); this.Needs = Reader.ReadInt32(); }
private List <BeatmapCollection> readCollections(Stream stream, ProgressNotification notification = null) { if (notification != null) { notification.Text = "Reading collections..."; notification.Progress = 0; } var result = new List <BeatmapCollection>(); try { using (var sr = new SerializationReader(stream)) { sr.ReadInt32(); // Version int collectionCount = sr.ReadInt32(); result.Capacity = collectionCount; for (int i = 0; i < collectionCount; i++) { if (notification?.CancellationToken.IsCancellationRequested == true) { return(result); } var collection = new BeatmapCollection { Name = { Value = sr.ReadString() } }; int mapCount = sr.ReadInt32(); for (int j = 0; j < mapCount; j++) { if (notification?.CancellationToken.IsCancellationRequested == true) { return(result); } string checksum = sr.ReadString(); collection.BeatmapHashes.Add(checksum); } if (notification != null) { notification.Text = $"Imported {i + 1} of {collectionCount} collections"; notification.Progress = (float)(i + 1) / collectionCount; } result.Add(collection); } } } catch (Exception e) { Logger.Error(e, "Failed to read collection database."); } return(result); }
public Association(SerializationInfo serializationInfo, StreamingContext streamingContext) { if (SerializerHelper.UseFastSerialization) { using (SerializationReader reader = new SerializationReader((byte[])serializationInfo.GetValue("d", typeof(byte[])))) { _UniqueId = reader.ReadString(); _AssociatedObjectId = reader.ReadString(); _AssociationKind = reader.ReadString(); _Mappings = (List<Mapping>)reader.ReadObject(); _Name = reader.ReadString(); _Enabled = reader.ReadBoolean(); } } else { if (SerializationVersionExists) { try { } catch (SerializationException) { // ignore SerializationVersionExists = false; } } _AssociatedObject = (ScriptObject)serializationInfo.GetValue("AssociatedObject", ModelTypes.ScriptObject); _PrimaryObject = (ScriptObject)serializationInfo.GetValue("PrimaryObject", ModelTypes.ScriptObject); _AssociationKind = serializationInfo.GetString("AssociationKind"); _Mappings = (List<Mapping>)serializationInfo.GetValue("Mappings", typeof(List<Mapping>)); _Name = serializationInfo.GetString("Name"); _Enabled = serializationInfo.GetBoolean("Enabled"); } }
public static async Task Handle(Packet p, Presence pr) { var match = pr.CurrentMatch; if (match is null) { return; } var reader = new SerializationReader(new MemoryStream(p.Data)); var newMatch = await reader.ReadMatch(); if (string.IsNullOrEmpty(newMatch.GamePassword)) { match.GamePassword = null; } match.GamePassword = newMatch.GamePassword; foreach (var presence in match.Presences) { await presence.MatchUpdate(match); } }
public void CreateWriter() { writer = new SerializationWriter(); reader = null; writerPosition = 0; writerLength = -1; }
public static Unit DeserializeUnit(SerializationReader reader) { BitVector32 state = reader.ReadOptimizedBitVector32(); int unitType = state[UnitType]; if (unitType == 0) { return(System.Web.UI.WebControls.Unit.Empty); } else if (state[UnitIsDoubleValue]) { return(new Unit(reader.ReadDouble(), (UnitType)unitType)); } else if (state[UnitIsZeroValue] == 1) { return(new Unit(0, (UnitType)unitType)); } else { int integerValue = state[UnitIsOptimizedValue] == 1 ? reader.ReadOptimizedInt32() : reader.ReadInt16(); if (state[UnitIsNegativeValue] == 1) { integerValue = -integerValue - 1; } return(new Unit(integerValue, (UnitType)unitType)); } }
public static StateBag DeserializeStateBag(SerializationReader reader) { BitVector32 flags = reader.ReadOptimizedBitVector32(); StateBag stateBag = new StateBag(flags[StateBagIsIgnoreCase]); if (flags[StateBagHasDirtyEntries]) { int count = reader.ReadOptimizedInt32(); for (int i = 0; i < count; i++) { string key = reader.ReadOptimizedString(); object value = reader.ReadObject(); stateBag.Add(key, value).IsDirty = true; } } if (flags[StateBagHasCleanEntries]) { int count = reader.ReadOptimizedInt32(); for (int i = 0; i < count; i++) { string key = reader.ReadOptimizedString(); object value = reader.ReadObject(); stateBag.Add(key, value); } } return(stateBag); }
public void Deserialize(byte[] mySerializedBytes) { var _SerializationReader = new SerializationReader(mySerializedBytes); FailedCopy = _SerializationReader.ReadInt32(); MaxNumberOfCopies = _SerializationReader.ReadInt32(); SerializedObjectStream = _SerializationReader.ReadByteArray(); }
public void Deserialize(byte[] mySerializedBytes) { var _SerializationReader = new SerializationReader(mySerializedBytes); ObjectLocation = _SerializationReader.ReadString(); NewDefaultRule = _SerializationReader.ReadOptimizedByte(); }
public void TestOutOfRange() { using (MemoryStream ms = new MemoryStream()) using (SerializationReader sr = new SerializationReader(ms)) { sr.Read<bool>(); sr.Read<byte>(); sr.Read<char>(); sr.Read<short>(); sr.Read<int>(); sr.Read<long>(); sr.Read<float>(); sr.Read<double>(); sr.Read<decimal>(); sr.Read<DateTime>(); sr.Read<string>(); sr.Read<TestEnum>(); sr.Read<string[]>(); sr.Read<List<string>>(); sr.Read<Dictionary<int, string>>(); sr.Read<TestSerializable>(); } }
public static Color DeserializeColor(SerializationReader reader) { BitVector32 flags = reader.ReadOptimizedBitVector32(); if (flags[ColorIsKnown]) { return(Color.FromKnownColor((KnownColor)reader.ReadOptimizedInt32())); } else if (flags[ColorHasName]) { return(Color.FromName(reader.ReadOptimizedString())); } else if (!flags[ColorHasValue]) { return(Color.Empty); } else { byte red = flags[ColorHasRed] ? reader.ReadByte() : (byte)0; byte green = flags[ColorHasGreen] ? reader.ReadByte() : (byte)0; byte blue = flags[ColorHasBlue] ? reader.ReadByte() : (byte)0; byte alpha = flags[ColorHasAlpha] ? reader.ReadByte() : (byte)0; return(Color.FromArgb(alpha, red, green, blue)); } }
public bScoreFrame(SerializationReader sr) { //checksum = sr.ReadString(); time = sr.ReadInt32(); id = sr.ReadByte(); count300 = sr.ReadUInt16(); count100 = sr.ReadUInt16(); count50 = sr.ReadUInt16(); countGeki = sr.ReadUInt16(); countKatu = sr.ReadUInt16(); countMiss = sr.ReadUInt16(); totalScore = sr.ReadInt32(); maxCombo = sr.ReadUInt16(); currentCombo = sr.ReadUInt16(); perfect = sr.ReadBoolean(); currentHp = sr.ReadByte(); tagByte = sr.ReadByte(); usingScoreV2 = sr.ReadBoolean(); comboPortion = usingScoreV2 ? sr.ReadDouble() : 0; bonusPortion = usingScoreV2 ? sr.ReadDouble() : 0; if (currentHp == 254) { currentHp = 0; pass = false; } else { pass = true; } }
//public string checksum; public bScoreFrame(Stream s) { SerializationReader sr = new SerializationReader(s); //checksum = sr.ReadString(); time = sr.ReadInt32(); id = sr.ReadByte(); count300 = sr.ReadUInt16(); count100 = sr.ReadUInt16(); count50 = sr.ReadUInt16(); countGeki = sr.ReadUInt16(); countKatu = sr.ReadUInt16(); countMiss = sr.ReadUInt16(); totalScore = sr.ReadInt32(); maxCombo = sr.ReadUInt16(); currentCombo = sr.ReadUInt16(); perfect = sr.ReadBoolean(); currentHp = sr.ReadByte(); if (currentHp == 254) { currentHp = 0; pass = false; } else { pass = true; } }
public bUserStats(Stream s, bool forceFull) { SerializationReader sr = new SerializationReader(s); userId = sr.ReadInt32(); Completeness comp = (Completeness)sr.ReadByte(); completeness = forceFull ? Completeness.Full : comp; status = new bStatusUpdate(s); if (completeness > Completeness.StatusOnly) { rankedScore = sr.ReadInt64(); accuracy = sr.ReadSingle(); playcount = sr.ReadInt32(); totalScore = sr.ReadInt64(); rank = sr.ReadUInt16(); } if (completeness == Completeness.Full) { username = sr.ReadString(); avatarFilename = sr.ReadString(); timezone = sr.ReadByte() - 24; location = sr.ReadString(); } }
public static TimingPoint ReadFromReader(SerializationReader r) { var t = new TimingPoint(); t.ReadFromStream(r); return(t); }
/// <summary> /// Opens and deserializes an index /// </summary> /// <param name="indexName"> The index name </param> /// <param name="indexPluginName"> The index plugin name </param> /// <param name="reader"> Serialization reader </param> /// <param name="fallen8"> Fallen-8 </param> internal void OpenIndex(string indexName, string indexPluginName, SerializationReader reader, Fallen8 fallen8) { IIndex index; if (PluginFactory.TryFindPlugin(out index, indexPluginName)) { index.Load(reader, fallen8); if (WriteResource()) { try { Indices.Add(indexName, index); return; } finally { FinishWriteResource(); } } throw new CollisionException(); } Logger.LogError(String.Format("Could not find index plugin with name \"{0}\".", indexPluginName)); }
private List <MarketOrder> GetAccountHistoryOrders(FarmAccount account) { var context = account.GetContext(); byte[] buffer; context.GetHistoryOrdersCompressed(account.AccountId, startDate, out buffer); if (buffer == null || buffer.Length == 0) { return(null); } try { using (var reader = new SerializationReader(buffer)) { var array = reader.ReadObjectArray(typeof(MarketOrder)); if (array != null && array.Length > 0) { return(array.Cast <MarketOrder>().ToList()); } return(null); } } catch (Exception ex) { Logger.Error("GetHistoryOrdersUncompressed() - serialization error", ex); return(null); } }
public static async Task Handle(Packet p, Presence pr) { var ms = new MemoryStream(p.Data); using var reader = new SerializationReader(ms); var presenceIds = new List <int>(); int length = reader.ReadInt16(); for (var i = 0; i < length; i++) { presenceIds.Add(reader.ReadInt32()); } foreach (var prId in presenceIds) { var otherPresence = PresenceManager.GetPresenceById(prId); if (otherPresence is not null) { await pr.UserPresence(otherPresence); } else { await pr.UserLogout(prId); } } }
/// <summary> /// Opens a serialized service /// </summary> /// <param name="serviceName">Service name</param> /// <param name="servicePluginName">Service plugin name</param> /// <param name="reader">Serialization reader</param> /// <param name="fallen8">Fallen-8</param> /// <param name="startService">Start the service?</param> internal void OpenService(string serviceName, string servicePluginName, SerializationReader reader, Fallen8 fallen8, Boolean startService) { IService service; if (PluginFactory.TryFindPlugin(out service, servicePluginName)) { if (WriteResource()) { try { if (Services.ContainsKey(serviceName)) { Logger.LogError(String.Format("A service with the same name \"{0}\" already exists.", serviceName)); } service.Load(reader, fallen8); if (service.TryStart()) { Services.Add(serviceName, service); } } finally { FinishWriteResource(); } return; } throw new CollisionException(); } Logger.LogError(String.Format("Could not find service plugin with name \"{0}\".", servicePluginName)); }
public RequestStatus GetHistoryOrdersUncompressed(int? accountId, DateTime? startDate, out List<MarketOrder> orders) { orders = null; byte[] buffer; var retVal = proxy.GetHistoryOrdersCompressed(accountId, startDate, out buffer); if (buffer == null || buffer.Length == 0) return retVal; try { using (var reader = new SerializationReader(buffer)) { var array = reader.ReadObjectArray(typeof (MarketOrder)); if (array != null && array.Length > 0) orders = array.Cast<MarketOrder>().ToList(); } } catch (Exception ex) { Logger.Error("GetHistoryOrdersUncompressed() - serialization error", ex); return RequestStatus.SerializationError; } return retVal; }
void IFastSerializable.Deserialize(SerializationReader reader) { base.Deserialize(reader); string name = reader.ReadString(); part = SpeechPart.GetPart(name); }
public static StateBag DeserializeStateBag(SerializationReader reader) { var flags = reader.ReadOptimizedBitVector32(); var stateBag = new StateBag(flags[StateBagIsIgnoreCase]); if (flags[StateBagHasDirtyEntries]) { var count = reader.ReadOptimizedInt32(); for(var i = 0; i < count; i++) { var key = reader.ReadOptimizedString(); var value = reader.ReadObject(); // ReSharper disable PossibleNullReferenceException stateBag.Add(key, value).IsDirty = true; // ReSharper restore PossibleNullReferenceException } } if (flags[StateBagHasCleanEntries]) { var count = reader.ReadOptimizedInt32(); for(var i = 0; i < count; i++) { var key = reader.ReadOptimizedString(); var value = reader.ReadObject(); stateBag.Add(key, value); } } return stateBag; }
public ForecastItem(SerializationInfo info, StreamingContext context) { var reader = SerializationReader.GetReader(info); AccountId = reader.ReadString(); Amount = reader.ReadInt64(); CategoryId = reader.ReadString(); CategoryName = reader.ReadString(); Date = reader.ReadDateTime(); if (reader.ReadBoolean()) { FlagColor = (FlagColor)reader.ReadByte(); } ForecastItemType = (ForecastItemType)reader.ReadByte(); Funded = reader.ReadInt64(); IsSplit = reader.ReadBoolean(); Memo = reader.ReadString(); PayeeId = reader.ReadString(); PayeeName = reader.ReadString(); ScheduledSubTransactionId = reader.ReadString(); ScheduledTransactionId = reader.ReadString(); SubTransactionId = reader.ReadString(); TransactionId = reader.ReadString(); TransferAccountId = reader.ReadString(); }
public override void Load(SerializationReader Reader) { this.village = HistoricEntity.Load(Reader, XRLCore.Core.Game.sultanHistory).GetCurrentSnapshot(); this.amount = Reader.ReadSingle(); this.faction = Factions.get(Reader.ReadString()); int countTales = Reader.ReadInt32(); this.historytales = new List <JournalVillageNote>(); List <JournalVillageNote> allnotes = JournalAPI.GetNotesForVillage(village.entity.id); for (int i = 0; i < countTales; i++) { string thissecretid = Reader.ReadString(); JournalVillageNote note = allnotes.FirstOrDefault(c => c.secretid == thissecretid); if (note != null) { this.historytales.Add(note); } } int counttales = Reader.ReadInt32(); this.tales = new List <string>(); for (int i = 0; i < counttales; i++) { this.tales.Add(Reader.ReadString()); } }
public void Deserialize(byte[] mySerializedBytes) { var reader = new SerializationReader(mySerializedBytes); ObjectLocation = reader.ReadString(); RightUUID = new UUID(reader.ReadByteArray()); EntitiyUUID = new UUID(reader.ReadByteArray()); }
/// <summary> /// Implementing the ISerializable to provide a faster, more optimized /// serialization for the class. /// </summary> public EnvelopeStamp(SerializationInfo info, StreamingContext context) { // Get from the info. SerializationReader reader = new SerializationReader((byte[])info.GetValue("data", typeof(byte[]))); _stampId = reader.ReadInt64(); _receiverId = (ClientId)reader.ReadObject(); _senderId = (ClientId)reader.ReadObject(); }
/// <exclude/> public Index(SerializationInfo serializationInfo, StreamingContext streamingContext) { if (SerializerHelper.UseFastSerialization) { _columns = null; using (SerializationReader reader = new SerializationReader((byte[])serializationInfo.GetValue("d", typeof(byte[])))) { UniqueId = reader.ReadString(); Lookups.Add(UniqueId, this); _alias = reader.ReadString(); _columnIds = reader.ReadStringArray(); _enabled = reader.ReadBoolean(); _isUserDefined = reader.ReadBoolean(); _name = reader.ReadString(); // TODO: Parent _type = reader.ReadString(); _userOptions = (List<IUserOption>)reader.ReadObject(); } } else { int version = 0; if (SerializationVersionExists) { try { version = serializationInfo.GetInt32("SerializationVersion"); } catch (SerializationException) { // ignore SerializationVersionExists = false; } } _alias = serializationInfo.GetString("Alias"); _columns = (List<Column>)serializationInfo.GetValue("Columns", ModelTypes.ColumnList); _enabled = serializationInfo.GetBoolean("Enabled"); //this._exposedUserOptions = serializationInfo.GetValue("ExposedUserOptions", ModelTypes.Object); _isUserDefined = serializationInfo.GetBoolean("IsUserDefined"); _name = serializationInfo.GetString("Name"); _parent = (ScriptObject)serializationInfo.GetValue("Parent", ModelTypes.ScriptObject); _type = serializationInfo.GetString("Type"); _userOptions = (List<IUserOption>)serializationInfo.GetValue("UserOptions", ModelTypes.UserOptionList); for (int i = 0; i < _userOptions.Count; i++) { _userOptions[i].Owner = this; } if (version >= 8) { _description = serializationInfo.GetString("Description"); } } }
public void Deserialize(byte[] Data) { SerializationReader reader = new SerializationReader(Data); AccountName = (String)reader.ReadObject(); DeviceID = (String)reader.ReadObject(); Timestamp = (String)reader.ReadObject(); Latitude = (String)reader.ReadObject(); Longitude = (String)reader.ReadObject(); AccuracyInMeters = (String)reader.ReadObject(); }
public void Deserialize(byte[] mySerializedBytes) { SerializationReader reader = new SerializationReader(mySerializedBytes); ServiceGlobalUniqueName = reader.ReadString(); String _ServiceUri = reader.ReadString(); ServiceType = (DiscoverableServiceType)reader.ReadOptimizedByte(); if (!Uri.TryCreate(_ServiceUri,UriKind.Absolute,out ServiceUri)) throw new NotificationException_InvalidNotificationPayload("IP not parseable. Notification Packet invalid!"); }
/// <summary> /// Implementing the ISerializable to provide a faster, more optimized /// serialization for the class using the fast serialization elements. /// </summary> public Envelope(SerializationInfo info, StreamingContext context) { // Get from the info. SerializationReader reader = new SerializationReader((byte[])info.GetValue("data", typeof(byte[]))); _duplicationMode = (DuplicationModeEnum)reader.ReadInt32(); _executionModel = (ExecutionModelEnum)reader.ReadInt32(); _message = reader.ReadObject(); _transportHistory = (EnvelopeTransportation)reader.ReadObject(); _transportTargetAddress = (EnvelopeTransportation)reader.ReadObject(); }
public static MarketOrder DeserializeOrder(SerializationReader reader) { var deal = new MarketOrder { ID = reader.ReadInt32(), AccountID = reader.ReadInt32(), Comment = reader.ReadString(), ExitReason = (PositionExitReason)reader.ReadInt16(), ExpertComment = reader.ReadString(), PriceEnter = reader.ReadSingle(), ResultDepo = reader.ReadSingle(), ResultPoints = reader.ReadSingle(), Side = reader.ReadSByte(), State = (PositionState) reader.ReadInt16(), Symbol = reader.ReadString(), TimeEnter = reader.ReadDateTime(), Trailing = reader.ReadString(), Volume = reader.ReadInt32(), VolumeInDepoCurrency = reader.ReadSingle() }; // nullable values var flags = reader.ReadOptimizedBitVector32(); if (flags[magicIsValued]) deal.Magic = reader.ReadInt32(); if (flags[pendingOrderIdIsValued]) deal.PendingOrderID = reader.ReadInt32(); if (flags[priceBestIsValued]) deal.PriceBest = reader.ReadSingle(); if (flags[priceExitIsValued]) deal.PriceExit = reader.ReadSingle(); if (flags[priceWorstIsValued]) deal.PriceWorst = reader.ReadSingle(); if (flags[stopLossIsValued]) deal.StopLoss = reader.ReadSingle(); if (flags[swapIsValued]) deal.Swap = reader.ReadSingle(); if (flags[takeProfitIsValued]) deal.TakeProfit = reader.ReadSingle(); if (flags[timeExitIsValued]) deal.TimeExit = reader.ReadDateTime(); return deal; }
public object Deserialize(SerializationReader reader, Type type) { if (type == typeof(Color)) { return DeserializeColor(reader); } else { throw new InvalidOperationException(string.Format("{0} does not support Type: {1}", GetType(), type)); } }
public void Deserialize(byte[] mySerializedBytes) { var _SerializationReader = new SerializationReader(mySerializedBytes); StorageURIs = new List<String>(); UInt32 numberOfStorageURIs = _SerializationReader.ReadUInt32(); for(UInt32 i=0; i<numberOfStorageURIs; i++) StorageURIs.Add(_SerializationReader.ReadString()); StorageType = _SerializationReader.ReadString(); StorageSize = _SerializationReader.ReadUInt64(); }
internal static readonly BitVector32.Section UnitType = BitVector32.CreateSection(9); // 4 bits #endregion Fields #region Methods // Note this is a simplistic version as it assumes defaults for comparer, hashcodeprovider, loadfactor etc. public static Hashtable DeserializeHashtable(SerializationReader reader) { var keys = reader.ReadOptimizedObjectArray(); var values = reader.ReadOptimizedObjectArray(); var result = new Hashtable(keys.Length); for(var i = 0; i < keys.Length; i++) { result[keys[i]] = values[i]; } return result; }
public void Deserialize(byte[] Data) { SerializationReader reader = new SerializationReader(Data); AccountName = (String)reader.ReadObject(); LatitudeID = (String)reader.ReadObject(); Timecode = (Int64)reader.ReadObject(); reverseGeocode = (String)reader.ReadObject(); Latitude = (Double)reader.ReadObject(); Longitude = (Double)reader.ReadObject(); AccuracyInMeters = (Int32)reader.ReadObject(); }
public void Deserialize(ref SerializationReader mySerializationReader) { Features = new List<FeatureIDs>(); UInt32 cnt = mySerializationReader.ReadUInt32(); for (int i = 0; i < cnt; i++) { byte entry = mySerializationReader.ReadOptimizedByte(); Features.Add((FeatureIDs)entry); } NumberOfLicensedCPUs = mySerializationReader.ReadInt32(); NumberOfLicensedRAM = mySerializationReader.ReadInt32(); }
/// <summary> /// Implementing the ISerializable to provide a faster, more optimized /// serialization for the class. /// </summary> /// <param name="info"></param> /// <param name="context"></param> public SuperPoolCall(SerializationInfo info, StreamingContext context) { // Get from the info. SerializationReader reader = new SerializationReader((byte[])info.GetValue("data", typeof(byte[]))); Id = reader.ReadInt64(); State = (StateEnum)reader.ReadInt32(); RequestResponse = reader.ReadBoolean(); Parameters = reader.ReadObjectArray(); string methodInfoName = reader.ReadString(); _methodInfoName = methodInfoName; MethodInfoLocal = SerializationHelper.DeserializeMethodBaseFromString(_methodInfoName, true); }
public void TestNull() { using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms)) using (SerializationReader sr = new SerializationReader(ms)) { sw.Write<object>(null); sw.Write<int[]>(null); sw.Write<List<int>>(null); sw.Write<Dictionary<int, string>>(null); sw.Write<TestSerializable>(null); } }
/// <summary> /// Implementing the ISerializable to provide a faster, more optimized /// serialization for the class. /// </summary> public EnvelopeTransportation(SerializationInfo info, StreamingContext context) { // Get from the info. SerializationReader reader = new SerializationReader((byte[])info.GetValue("data", typeof(byte[]))); object[] stamps = reader.ReadObjectArray(); if (stamps.Length == 0) { _stamps = new Deque<EnvelopeStamp>(); } else { _stamps = new Deque<EnvelopeStamp>((EnvelopeStamp[])stamps); } }
public static Color DeserializeColor(SerializationReader reader) { var flags = reader.ReadOptimizedBitVector32(); if (flags[ColorIsKnown]) return Color.FromKnownColor((KnownColor) reader.ReadOptimizedInt32()); if (flags[ColorHasName]) return Color.FromName(reader.ReadOptimizedString()); if (!flags[ColorHasValue]) return Color.Empty; var red = flags[ColorHasRed] ? reader.ReadByte() : (byte) 0; var green = flags[ColorHasGreen] ? reader.ReadByte() : (byte) 0; var blue = flags[ColorHasBlue] ? reader.ReadByte() : (byte) 0; var alpha = flags[ColorHasAlpha] ? reader.ReadByte() : (byte) 0; return Color.FromArgb(alpha, red, green, blue); }
public void TestUTF16Chars() { using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms, new UnicodeEncoding())) using (SerializationReader sr = new SerializationReader(ms, new UnicodeEncoding())) { for (int i = 0; i < 55296; i++) sw.Write((char)i); sw.Flush(); ms.Position = 0; for (int i = 0; i < 55296; i++) Assert.AreEqual((char)i, sr.Read<char>()); } }
public void TestUTF16String() { using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms, new UnicodeEncoding())) using (SerializationReader sr = new SerializationReader(ms, new UnicodeEncoding())) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < 55296; i++) sb.Append((char)i); string res = sb.ToString(); sw.Write(res); sw.Flush(); ms.Position = 0; Assert.AreEqual(res, sr.Read<string>()); } }
/// <exclude/> public UserOption(SerializationInfo serializationInfo, StreamingContext streamingContext) : base() { try { using (Slyce.Common.SerializationReader reader = new SerializationReader((byte[])serializationInfo.GetValue("d", typeof(byte[])))) { _name = reader.ReadString(); _dataType = (Type)reader.ReadObject(); _value = reader.ReadObject(); } } catch { this._name = serializationInfo.GetString("_name"); this._dataType = (Type)serializationInfo.GetValue("_dataType", typeof(Type)); this._value = serializationInfo.GetValue("_value", typeof(object)); } }
public void TestBytes() { Random rand = new Random(); using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms)) using (SerializationReader sr = new SerializationReader(ms)) { byte[] values = new byte[Config.MULTI_TEST_COUNT]; rand.NextBytes(values); for (int i = 0; i < Config.MULTI_TEST_COUNT; i++) sw.Write(values[i]); sw.Flush(); ms.Position = 0; for (int i = 0; i < Config.MULTI_TEST_COUNT; i++) Assert.AreEqual(values[i], sr.Read<byte>()); } }
public void TestBasicDictionary() { Random rand = new Random(); using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms)) using (SerializationReader sr = new SerializationReader(ms)) { Dictionary<int, float> dict = new Dictionary<int, float>(Config.MULTI_TEST_COUNT); for (int i = 0; i < Config.MULTI_TEST_COUNT; i++) dict[rand.Next(int.MinValue, int.MaxValue)] = (float)rand.NextDouble(); sw.Write(dict); sw.Flush(); ms.Position = 0; Dictionary<int, float> ret = sr.Read<Dictionary<int, float>>(); foreach (KeyValuePair<int, float> kvp in dict) Assert.AreEqual(kvp.Value, ret[kvp.Key]); } }
public void TestBasicArray() { Random rand = new Random(); using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms)) using (SerializationReader sr = new SerializationReader(ms)) { int[] array = new int[Config.MULTI_TEST_COUNT]; for (int i = 0; i < Config.MULTI_TEST_COUNT; i++) array[i] = rand.Next(int.MinValue, int.MaxValue); sw.Write(array); sw.Flush(); ms.Position = 0; int[] ret = sr.Read<int[]>(); for (int i = 0; i < ret.Length; i++) Assert.AreEqual(array[i], ret[i]); } }
public void TestBasicList() { Random rand = new Random(); using (MemoryStream ms = new MemoryStream()) using (SerializationWriter sw = new SerializationWriter(ms)) using (SerializationReader sr = new SerializationReader(ms)) { List<int> list = new List<int>(Config.MULTI_TEST_COUNT); for (int i = 0; i < Config.MULTI_TEST_COUNT; i++) list.Add(rand.Next(int.MinValue, int.MaxValue)); sw.Write(list); sw.Flush(); ms.Position = 0; List<int> ret = sr.Read<List<int>>(); for (int i = 0; i < list.Count; i++) Assert.AreEqual(list[i], ret[i]); } }
public object Deserialize(SerializationReader reader, Type type) { if (type == typeof(Pair)) return DeserializePair(reader); else if (type == typeof(Triplet)) return DeserializeTriplet(reader); else if (type == typeof(StateBag)) return DeserializeStateBag(reader); else if (type == typeof(Unit)) return DeserializeUnit(reader); else if (type == typeof(Hashtable)) return DeserializeHashtable(reader); else { throw new InvalidOperationException(string.Format("{0} does not support Type: {1}", GetType(), type)); } }