public override void WritePayload(IValueWriter writerm) { writerm.WriteUInt32(this.NetworkID); writerm.WriteString(this.CharacterName); writerm.WriteByte((byte)this.Action); }
public void Write(IValueWriter writer) { writer.Write(_grhIndexValueKey, GrhIndex); writer.Write(_sourceValueKey, SourceName); writer.Write(_destValueKey, DestName); writer.Write(_offsetValueKey, Offset); writer.Write(_originValueKey, Origin); }
public override void WritePayload(IValueWriter writer) { if (String.IsNullOrEmpty (this.Password)) throw new InvalidOperationException ("Can not login without a password."); writer.WriteString (Username); writer.WriteString (Password); }
public override void WritePayload(ISerializationContext context, IValueWriter writer) { using (var ms = new MemoryStream()) { ScreenFrame.Save(ms, ImageFormat.Png); writer.WriteBytes(ms.GetBuffer()); } }
public override void WritePayload(IValueWriter writer) { base.WritePayload(writer); writer.WriteBytes(InternalOwnEndPoint.Address.GetAddressBytes()); writer.WriteInt32(InternalOwnEndPoint.Port); writer.WriteBytes(ExternalPeerEndPoint.Address.GetAddressBytes()); writer.WriteInt32(ExternalPeerEndPoint.Port); }
public override void WritePayload (ISerializationContext context, IValueWriter writer) { if (writer.WriteBool (SenderId != null)) writer.WriteString (SenderId); writer.WriteInt32 (GroupId); writer.WriteString (Text); }
/// <summary> /// Writes all properties for the given <paramref name="obj"/> that have the <see cref="SyncValueAttribute"/> /// attribute to the given <see cref="IValueWriter"/>. /// </summary> /// <param name="obj">The object to write the persistent values for.</param> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> public static void Write(object obj, IValueWriter writer) { var propertySyncs = PropertySyncHelper.GetPropertySyncs(obj.GetType()); foreach (var ps in propertySyncs) { ps.WriteValue(obj, writer); } }
public override void WritePayload(ISerializationContext context, IValueWriter writer) { writer.WriteInt32 (Entities.Count); foreach (SnapshotEntity sentity in Entities) { WriteEntity (sentity.Entity, context, writer); } }
public void Serialize(IValueWriter writer) { writer.WriteBool (this.NonCharacter); writer.WriteInt32 (this.PlayerID); writer.WriteInt32 (this.path.Count); foreach(Directions dir in this.path) writer.WriteInt32 ((int) dir); }
public override void WritePayload(IValueWriter writer) { writer.WriteUInt32 (this.NetworkID); writer.WriteInt32 (this.X); writer.WriteInt32 (this.Y); writer.WriteInt32 (this.Direction); writer.WriteString (this.Animation); }
public override void WritePayload(IValueWriter writer) { writer.WriteInt32 (this.EventCommands.Count); foreach(IEventCommand command in this.EventCommands) { writer.WriteInt32 ((int) command.Command); command.Serialize (writer); } }
internal NetworkServerConnection(NetworkServerConnectionProvider provider, uint nid, TcpClient tcp, IPEndPoint endPoint, IValueWriter uwriter) { this.NetworkId = nid; this.Tcp = tcp; this.ReliableStream = tcp.GetStream (); this.provider = provider; this.EndPoint = endPoint; this.UnreliableWriter = uwriter; this.ReliableReader = new StreamValueReader (ReliableStream); this.ReliableWriter = new StreamValueWriter (ReliableStream); }
/// <summary> /// Writes the state of the object to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param> public void WriteState(IValueWriter writer) { PersistableHelper.Write(this, writer); // Equipped bodies Debug.Assert(_equippedBodies.Count <= byte.MaxValue); writer.Write("EquippedBodiesCount", (byte)_equippedBodies.Count); for (var i = 0; i < _equippedBodies.Count; i++) { writer.Write("EquippedBody_" + i, _equippedBodies[i]); } }
/// <summary> /// 将指定成员名称的值写入到值写入器中。 /// </summary> /// <param name="key">成员的名称</param> /// <param name="valueWriter">值写入器</param> public void OnReadValue(string key, IValueWriter valueWriter) { if (xTypeInfo.rwFieldsCache.TryGetValue(key, out var field)) { if (field.CanRead) { field.OnReadValue(obj, valueWriter); } else if ((xTypeInfo.flags & XBindingFlags.RWCannotGetException) != 0) { throw new MissingMethodException($"Property '{xTypeInfo.type.Name}.{key}' No define '{"get"}' method or cannot access."); } } else if ((xTypeInfo.flags & XBindingFlags.RWNotFoundException) != 0) { throw new MissingMemberException(xTypeInfo.type.Name, key); } else { valueWriter.DirectWrite(null); } }
/// <summary> /// Writes the <see cref="BackgroundImage"/> to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> public virtual void Write(IValueWriter writer) { writer.Write(_valueKeyName, Name); writer.WriteEnum(_valueKeyAlignment, Alignment); writer.Write(_valueKeyColor, Color); writer.Write(_valueKeyDepth, Depth); writer.Write(_valueKeyOffset, Offset); GrhIndex grhIndex; if (IsSpriteSet()) { grhIndex = Sprite.GrhData.GrhIndex; } else { grhIndex = GrhIndex.Invalid; Debug.Fail("Why is the Sprite not set? That doesn't seem right..."); } writer.Write(_valueKeyGrhIndex, grhIndex); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value == null) { valueWriter.DirectWrite(null); return; } if (valueWriter is IValueWriter <T> tWriter) { tWriter.WriteValue(value); return; } var dataReader = new DataSetRW <T>(); dataReader.Initialize(value); valueWriter.WriteArray(dataReader); }
/// <summary> /// Writes a <see cref="IRefractionEffect"/> to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> /// <param name="re">The <see cref="IRefractionEffect"/> to write.</param> /// <exception cref="ArgumentException"><paramref name="re"/> is not in the <see cref="ValidTypes"/>.</exception> /// <exception cref="ArgumentNullException"><paramref name="re"/> is null.</exception> /// <exception cref="ArgumentNullException"><paramref name="writer"/> is null.</exception> public static void Write(IValueWriter writer, IRefractionEffect re) { if (writer == null) { throw new ArgumentNullException("writer"); } if (re == null) { throw new ArgumentNullException("re"); } var asPersistable = re as IPersistable; string typeName = null; if (asPersistable != null) { typeName = Instance[re.GetType()]; } if (typeName == null) { const string errmsg = "Type `{0}` is not a valid persistable IRefractionEffect type."; if (log.IsErrorEnabled) { log.ErrorFormat(errmsg, re.GetType()); } throw new ArgumentException(string.Format(errmsg, re.GetType()), "re"); } writer.Write(_refractionEffectTypeKeyName, typeName); writer.WriteStartNode(_refractionEffectNodeName); { asPersistable.WriteState(writer); } writer.WriteEndNode(_refractionEffectNodeName); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value is null) { valueWriter.DirectWrite(null); return; } if (valueWriter is IValueWriter <T> tWriter) { tWriter.WriteValue(value); return; } var dataReader = new DataRowRW <T> { datarow = value }; valueWriter.WriteObject(dataReader); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value == null) { valueWriter.DirectWrite(null); return; } /* 父类引用,子类实例时使用 Type 获取写入器。 */ if (CheckDerivedInstance && TypeHandle != TypeHelper.GetTypeHandle(value)) { ValueInterface.GetInterface(value).Write(valueWriter, value); return; } var reader = FastObjectRW <T> .Create(); reader.Initialize(value); valueWriter.WriteObject(reader); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value is null) { valueWriter.DirectWrite(null); return; } if (valueWriter is IValueWriter <T> tWriter) { tWriter.WriteValue(value); return; } var dataReader = new DataSetRW <T> { dataset = value }; valueWriter.WriteArray(dataReader); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value is null) { valueWriter.DirectWrite(null); return; } if (valueWriter is IValueWriter <T> weiter) { weiter.WriteValue(value); return; } var reader = new DataTableRW <T>(GetDataTableRWOptions(valueWriter)) { datatable = value }; valueWriter.WriteArray(reader); }
public void WriteValue(IValueWriter valueWriter, T value) { if (valueWriter is IValueWriter <T> tWriter) { tWriter.WriteValue(value); } else if (valueWriter is IValueWriter <IDataReader <TKey> > tWriter2) { tWriter2.WriteValue(value); } else if (valueWriter is IValueWriter <IDataReader> tWriter3) { tWriter3.WriteValue(value); } else if (RWHelper.IsArrayKey <TKey>()) { valueWriter.WriteArray(value.As <int>()); } else { valueWriter.WriteObject(value.As <string>()); } }
/// <summary> /// When overridden in the derived class, writes the information for an item. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> /// <param name="itemInfo">The item info to write.</param> protected override void WriteItemInfo(IValueWriter writer, IItemTable itemInfo) { var asPersistable = itemInfo as IPersistable; if (asPersistable != null) { // Implements IPersistable, so can easily write the state asPersistable.WriteState(writer); } else { // Doesn't implement IPersistable, so we have to create an ItemTable which is able to load the values from an IItemTable // and does implement IPersistable. To avoid creating garbage, we cache an ItemTable to use instead of creating // a new instance every time. Of course, this also means we need thread safety. // This operation is quite fast (just lots of copying values around) so it would probably be of greater cost to try // and allow parallization by using multiple ItemTable caches. lock (_itemTableInfoCacheSync) { _itemTableInfoCache.CopyValuesFrom(itemInfo); _itemTableInfoCache.WriteState(writer); } } }
/// <summary> /// 在数据写入器中写入该类型的实例。 /// </summary> /// <param name="valueWriter">值写入器</param> /// <param name="value">该类型的实例</param> public void WriteValue(IValueWriter valueWriter, T value) { if (value == null) { valueWriter.DirectWrite(null); return; } /* 父类引用,子类实例时使用 Type 获取写入器。 */ if (CheckChildrenInstance && TypeHandle != TypeHelper.GetTypeHandle(value)) { ValueInterface.WriteValue(valueWriter, value); return; } var objectRW = XObjectRW.Create <T>(CurrentBindingFlags); objectRW.Initialize(value); valueWriter.WriteObject(objectRW); }
public void WriteValue(IValueWriter valueWriter, T value) { if (value == null) { valueWriter.DirectWrite(null); return; } /* 父类引用,子类实例时使用 Type 获取写入器。 */ if (CheckChildrenInstance && Int64TypeHandle != (long)TypeHelper.GetTypeHandle(value)) { ValueInterface.GetInterface(value).Write(valueWriter, value); return; } var fastObjectRW = FastObjectRW <T> .Create(); fastObjectRW.Initialize(value); valueWriter.WriteObject(fastObjectRW); }
public void WriteValue(IValueWriter valueWriter, T value) { switch (TypeInfo <Key> .BasicType) { case BasicTypes.SByte: case BasicTypes.Int16: case BasicTypes.Int32: case BasicTypes.Int64: case BasicTypes.Byte: case BasicTypes.UInt16: case BasicTypes.UInt32: case BasicTypes.UInt64: valueWriter.WriteArray(value.As <int>()); break; case BasicTypes.Char: case BasicTypes.String: valueWriter.WriteObject(value.As <string>()); break; default: throw new NotSupportedException(StringHelper.Format("Cannot write a '{0}', It's Key not supported.", typeof(T).Name)); } }
/// <summary> /// Writes a signed integer with the specified range to an IValueWriter. /// </summary> /// <param name="writer">IValueWriter to write to.</param> /// <param name="value">Value to write.</param> /// <param name="name">Name of the value to write.</param> /// <param name="minValue">Minimum (inclusive) value that the written value can be.</param> /// <param name="maxValue">Maximum (inclusive) value that the written value can be.</param> /// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is greater than <paramref name="maxValue"/> /// or less than <paramref name="minValue"/>.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxValue"/> is less than <paramref name="minValue"/>.</exception> public static void Write(this IValueWriter writer, string name, int value, int minValue, int maxValue) { if (value < minValue || value > maxValue) { throw new ArgumentOutOfRangeException("value", "Value parameter must be between minValue and maxValue."); } if (maxValue < minValue) { throw new ArgumentOutOfRangeException("maxValue", "MaxValue must be greater than or equal to MinValue."); } // Find the number of bits required for the range of desired values var maxWriteValue = (uint)(maxValue - minValue); var bitsRequired = BitOps.RequiredBits(maxWriteValue); // Subtract the minimum value from the value since we want to write how high above the minimum value // the value is, not the actual value var offsetFromMin = (uint)(value - minValue); writer.Write(name, offsetFromMin, bitsRequired); Debug.Assert((value - minValue) <= maxWriteValue); Debug.Assert((1 << bitsRequired) >= maxWriteValue); }
public void WriteValue(IValueWriter valueWriter, ValueTask value) { var task = value.AsTask(); try { task.Wait(); ValueInterface.WriteValue(valueWriter, new { task.AsyncState, task.Status }); } catch { ValueInterface.WriteValue(valueWriter, new { task.AsyncState, task.Exception.InnerException, task.Status }); } }
public SlimeMode2Encoder(IValueWriter valueWriter) { _valueWriter = valueWriter; }
/// <summary> /// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param> protected override void WriteCustomValues(IValueWriter writer) { }
/// <summary> /// When overridden in the derived class, writes a value to an IValueWriter with the specified name. /// </summary> /// <param name="name">Name of the value.</param> /// <param name="writer">IValueWriter to write to.</param> /// <param name="value">Value to write.</param> protected override void Write(string name, IValueWriter writer, Vector3 value) { writer.Write(name, value); }
public override void WritePayload(ISerializationContext context, IValueWriter writer) { writer.WriteInt32(GroupId); }
static void WriteKVP(IValueWriter writer, KeyValuePair<string, string> value) { writer.Write(_keyValueName, value.Key); writer.Write(_valueValueName, value.Value ?? string.Empty); }
/// <summary> /// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param> protected override void WriteCustomValues(IValueWriter writer) { writer.Write("SerializedValue", SerializedValue); }
internal void Serialize(IValueWriter writer) { writer.WriteInt32 (this.UserId); writer.WriteByte ((byte)this.ResultState); }
public void OnReadValue(TKey key, IValueWriter valueWriter) { ValueInterface <TValue> .WriteValue(valueWriter, content[key]); }
/// <summary> /// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param> protected override void WriteCustomValues(IValueWriter writer) { writer.Write(_positionKeyName, Position); writer.Write(_radiusKeyName, Radius); writer.Write(_strengthKeyName, Strength); }
public void WriteJson(object value, IValueWriter writer) { var flag = (FeatureFlag)value; var obj = writer.Object(); obj.Name("key").String(flag.Key); obj.Name("version").Int(flag.Version); obj.Name("deleted").Bool(flag.Deleted); obj.Name("on").Bool(flag.On); var prereqsArr = obj.Name("prerequisites").Array(); foreach (var p in flag.Prerequisites) { var prereqObj = prereqsArr.Object(); prereqObj.Name("key").String(p.Key); prereqObj.Name("variation").Int(p.Variation); prereqObj.End(); } prereqsArr.End(); var targetsArr = obj.Name("targets").Array(); foreach (var t in flag.Targets) { var targetObj = targetsArr.Object(); targetObj.Name("variation").Int(t.Variation); SerializationHelpers.WriteStrings(targetObj.Name("values"), t.Values); targetObj.End(); } targetsArr.End(); var rulesArr = obj.Name("rules").Array(); foreach (var r in flag.Rules) { var ruleObj = rulesArr.Object(); ruleObj.Name("id").String(r.Id); SerializationHelpers.WriteVariationOrRollout(ref ruleObj, r.Variation, r.Rollout); SerializationHelpers.WriteClauses(ruleObj.Name("clauses"), r.Clauses); ruleObj.Name("trackEvents").Bool(r.TrackEvents); ruleObj.End(); } rulesArr.End(); var fallthroughObj = obj.Name("fallthrough").Object(); SerializationHelpers.WriteVariationOrRollout(ref fallthroughObj, flag.Fallthrough.Variation, flag.Fallthrough.Rollout); fallthroughObj.End(); if (flag.OffVariation.HasValue) { obj.Name("offVariation").Int(flag.OffVariation.Value); } SerializationHelpers.WriteValues(obj.Name("variations"), flag.Variations); obj.Name("salt").String(flag.Salt); obj.MaybeName("trackEvents", flag.TrackEvents).Bool(flag.TrackEvents); obj.MaybeName("trackEventsFallthrough", flag.TrackEventsFallthrough).Bool(flag.TrackEventsFallthrough); if (flag.DebugEventsUntilDate.HasValue) { obj.Name("debugEventsUntilDate").Long(flag.DebugEventsUntilDate.Value.Value); } obj.Name("clientSide").Bool(flag.ClientSide); obj.End(); }
/// <summary> /// When overridden in the derived class, writes the values unique to this derived type to the /// <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> protected override void WriteCustomValues(IValueWriter writer) { writer.Write(_automaticSizeValueKey, AutomaticSize); writer.WriteStartNode(_textureNodeName); writer.Write(_textureNameValueKey, TextureName); writer.Write(_textureSourceValueKey, OriginalSourceRect); writer.WriteEndNode(_textureNodeName); }
/// <summary> /// When overridden in the derived class, writes a value to an IValueWriter with the specified name. /// </summary> /// <param name="name">Name of the value.</param> /// <param name="writer">IValueWriter to write to.</param> /// <param name="value">Value to write.</param> protected override void Write(string name, IValueWriter writer, SPValueType value) { value.Write(writer, name); }
public void OnReadValue(object obj, IValueWriter valueWriter) { ValueInterface <TValue> .Content.WriteValue(valueWriter, value); }
/// <summary> /// Writes the state of the object to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param> void IPersistable.WriteState(IValueWriter writer) { PersistableHelper.Write(this, writer); /* writer.Write(_keyID, ID); writer.Write(_keyHasSound, Sound.HasValue); writer.Write(_keySoundID, (Sound.HasValue ? Sound.Value : new SoundID(0))); writer.Write(_keyScript, Script); writer.Write(_keyGrhIndex, GrhIndex); writer.Write(_keyParticleEffect, ParticleEffect);*/ }
public void WriteValue(IValueWriter valueWriter, T value) { Get(valueWriter as ITargetedBind).WriteValue(valueWriter, value); }
public void WriteValue(IValueWriter valueWriter, DateTimeOffset value) { valueWriter.WriteString(value.ToString(format)); }
/// <summary> /// Writes the <see cref="ColumnSchema"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> public void Write(IValueWriter writer) { var v = _values.OrderBy(x => x.Key).ToArray(); writer.WriteManyNodes(_valuesNodeName, v, WriteKVP); }
/// <summary> /// Writes the <see cref="Skeleton"/> to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write to.</param> /// <exception cref="ArgumentNullException"><paramref name="writer" /> is <c>null</c>.</exception> public void Write(IValueWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); writer.WriteManyNodes(_nodesNodeName, RootNode.GetAllNodes(), ((w, item) => item.Write(w))); }
/// <summary> /// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param> protected override void WriteCustomValues(IValueWriter writer) { writer.Write(_heightKeyName, Height); writer.Write(_widthKeyName, Width); writer.Write(_perimeterKeyName, Perimeter); }
public void OnReadValue(object obj, IValueWriter valueWriter) { Assert(CanRead, "get"); ValueInterface <TValue> .Content.WriteValue(valueWriter, _get(obj)); }
public void WriteValue(IValueWriter valueWriter, ushort value) { valueWriter.WriteUInt16(value); }
/// <summary> /// Writes the <see cref="GuildID"/> to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">IValueWriter to write to.</param> /// <param name="name">Unique name of the <see cref="GuildID"/> that will be used to distinguish it /// from other values when reading.</param> public void Write(IValueWriter writer, string name) { writer.Write(name, _value); }
/// <summary> /// Writes the <see cref="NPCChatDialogBase"/>'s values to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer"><see cref="IValueWriter"/> to write the values to.</param> public void Write(IValueWriter writer) { var items = GetDialogItems(); writer.Write(_nodeValueKeyID, ID); writer.Write(_nodeValueKeyTitle, Title); writer.WriteManyNodes(_nodeValueKeyItems, items, ((w, item) => item.Write(w))); }
/// <summary> /// Writes a <see cref="GuildID"/> to a <see cref="IValueWriter"/>. /// </summary> /// <param name="valueWriter"><see cref="IValueWriter"/> to write to.</param> /// <param name="name">Unique name of the <see cref="GuildID"/> that will be used to distinguish it /// from other values when reading.</param> /// <param name="value"><see cref="GuildID"/> to write.</param> public static void Write(this IValueWriter valueWriter, string name, GuildID value) { value.Write(valueWriter, name); }
/// <summary> /// Writes the state of the object to an <see cref="IValueWriter"/>. /// </summary> /// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param> public virtual void WriteState(IValueWriter writer) { PersistableHelper.Write(this, writer); }
public override void WritePayload(ISerializationContext context, IValueWriter writer) { if (writer.WriteBool (Accepted)) Target.Serialize (context, writer); }
public void Serialize(IValueWriter writer) { }
private void WriteEntity(NetworkEntity entity, ISerializationContext context, IValueWriter writer) { writer.WriteString (entity.EntityName); writer.WriteUInt16 ((UInt16)entity.NetworkID); writer.WriteUInt16 ((UInt16)entity.Fields.Count); foreach (var kvp in entity.Fields) { object fieldValue = kvp.Value.Value; writer.WriteString (kvp.Key); // Write the field type ushort typeID; context.TypeMap.GetTypeId (fieldValue.GetType (), out typeID); writer.WriteUInt16 (typeID); if (fieldValue is Vector2) writer.Write (context, (Vector2)fieldValue, Vector2Serializer.Instance); else if (fieldValue is Vector3) writer.Write (context, (Vector3)fieldValue, Vector3Serializer.Instance); else writer.Write (context, fieldValue, kvp.Value.Type); } }
public void Write(IValueWriter writer) { writer.WriteManyNodes(_itemsNodeName, Items, ((w, item) => item.Write(w))); }
public void WriteValue(IValueWriter valueWriter, JsonValue value) { ValueInterface.WriteValue(valueWriter, value.value); }
public override void WritePayload (ISerializationContext context, IValueWriter writer) { writer.WriteString (Nickname); }