/// <summary> /// Request the packet object write out all of its fields. /// </summary> /// <param name="packet"></param> /// <param name="writer"></param> internal void WriteFields(IPacket packet, IFieldWriter writer) { if (packet is GenericPacket) { //TODO: Update generic packet handling //packet.WriteFields(writer); } else { //We need all of our base classes to write out before us if (m_BasePacket != null) { m_BasePacket.WriteFields(packet, writer); } //and finally write out our information, if we have any. if (m_WriteMethod != null && m_Fields.Count > 0) { //we need to create a serialized packet for this new level so the write method can store information SerializedPacket serializedPacket = new SerializedPacket(this); m_WriteMethod.Invoke(packet, new object[] { this, serializedPacket }); //and now write out the fields to serialization. for (int curFieldIndex = 0; curFieldIndex < Fields.Count; curFieldIndex++) { FieldDefinition fieldDefinition = Fields[curFieldIndex]; writer.Write(serializedPacket.Values[curFieldIndex], fieldDefinition.FieldType); } } } }
public static Task SetValueAsync <TItem>(this IFieldWriter <TItem> writer, TItem item, object deserializedValue, IDataTransaction dataTransaction) where TItem : class { var loadedItem = new LoadedItem <TItem>(item); return(writer.SetValueAsync(loadedItem, deserializedValue, dataTransaction)); }
/// <summary> /// Helper method to write out a single run (either repating or unique values) /// </summary> private void WriteRun(T[] array, IFieldWriter writer, ref int runLength, ref int currentIndex, ref int peekIndex) { // This handles the edge case of the last run containing only one value if (currentIndex == array.Length - 1) { runLength = -1; } // Write the length of the run first writer.Write(runLength); // is this a repeating run? if (runLength > 0) { // for a repeating run, write the value once but advance the index by runLength WriteValue(writer, array[currentIndex]); currentIndex += runLength; } else { // for a unique run, write each value while (runLength < 0) { WriteValue(writer, array[currentIndex++]); runLength++; } } // Having written this run, get ready for the next one peekIndex = currentIndex + 1; runLength = 0; }
internal void Write(IFieldWriter writer) { writer.WriteValueU32((byte)this._Value.Type); writer.WriteValueU32(((byte)this._Function) & 3u); writer.WriteValueU32(this._Index & 0x7FFu); this._Value.Write(writer); writer.WriteValueF32(this._Factor); }
public void WriteDefinition(IFieldWriter writer) { writer.Write(m_IsCachable); int nestingDepth = GetNestingDepth(); writer.Write(nestingDepth); writer.Write(m_DynamicTypeName); WriteDefinitionForThisLevel(writer); }
/// <summary> /// Initialize a PacketWriter to read the specified stream using /// the provided encoding for strings. /// </summary> /// <param name="stream">Destination for data written</param> /// <param name="majorVersion">Major version of the serialization protocol</param> /// <param name="minorVersion">Minor version of the serialization protocol</param> public PacketWriter(Stream stream, int majorVersion, int minorVersion) { m_Stream = stream; m_Writer = new FieldWriter(stream, new UniqueStringList(), majorVersion, minorVersion); m_Buffer = new MemoryStream(); m_BufferWriter = new FieldWriter(m_Buffer, m_Writer.Strings, majorVersion, minorVersion); m_CachedTypes = new PacketDefinitionList(); m_PacketCache = new PacketCache(); }
public async Task SetReadOnlyField_Throws() { IFieldWriter <Artist> writer = Provider.GetWriter("ID"); //Assert.IsNull(writer); await Assert.ThrowsAsync <InvalidOperationException>(async delegate { await writer.SetValueAsync(Item, 111, new VoidTransaction()); }); }
public SimpleTypeWriter( ITypeQueryFactory typeQueryFactory, ITypeNameWriter typeNameWriter, ITypeNameConverter typeNameConverter, IEventWriter eventWriter, IMethodWriter methodWriter, IFieldWriter fieldWriter, IPropertyWriter propertyWriter) { _typeQueryFactory = typeQueryFactory; _typeNameWriter = typeNameWriter; _typeNameConverter = typeNameConverter; _eventWriter = eventWriter; _methodWriter = methodWriter; _fieldWriter = fieldWriter; _propertyWriter = propertyWriter; }
public PlantUmlTypeWriter( IQueryType queryType, ITypeNameWriter typeNameWriter, ITypeNameWriter escapedTypeNameWriter, IEventWriter eventWriter, IMethodWriter methodWriter, IFieldWriter fieldWriter, IPropertyWriter propertyWriter) { _queryType = queryType; _typeNameWriter = typeNameWriter; _escapedTypeNameWriter = escapedTypeNameWriter; _eventWriter = eventWriter; _methodWriter = methodWriter; _fieldWriter = fieldWriter; _propertyWriter = propertyWriter; }
internal override void Write(IFieldWriter writer) { writer.WriteValueS32(this._Includes.Count); writer.WriteValueS32(this._Properties.Count); writer.WriteValueB8(this._Unknown1B); writer.WriteValueB8(this._Unknown1C); writer.WriteValueU32((uint)this._ObjectType); writer.WriteValueU8(this._Unknown19); writer.WriteValueU8(this._Unknown1A); writer.WriteValueU32(this._KeywordId); writer.WriteValueS32(this._KeywordIds.Count); foreach (var keywordId in this._KeywordIds) { writer.WriteValueU32(keywordId); } writer.WriteValueS32(this._Unknown98.Count); foreach (var item in this._Unknown98) { writer.WriteValueU32(item.Item1); writer.WriteValueU32(item.Item2); } foreach (var include in this._Includes) { writer.WriteValueU32(include.Item1); writer.WriteValueU8(include.Item2); writer.WriteValueB8(include.Item3); writer.WriteValueB8(include.Item4); } foreach (var property in this._Properties) { property.Write(writer); } }
static ITypeWriter CreatePlantUmlTypeWriter() { bool writeMembers = true; var queryType = new QueryType(new TypeQueryOptions()); var normalTypeNameConverter = new SimpleTypeNameConverter(); var escapingTypeNameConverter = new EscapingTypenameConverter(); var normalTypeNameWriter = new SimpleTypeNameWriter(normalTypeNameConverter); var escapedTypeNameWriter = new SimpleTypeNameWriter(escapingTypeNameConverter); IPropertyWriter propertyWriter = writeMembers ? new PropertyWriter(normalTypeNameWriter) : new EmptyPropertyWriter(); IMethodWriter methodWriter = writeMembers ? new MethodWriter(normalTypeNameConverter, normalTypeNameWriter) : new EmptyMethodWriter(); IFieldWriter fieldWriter = writeMembers ? new FieldWriter(normalTypeNameWriter) : new EmptyFieldWriter(); IEventWriter eventWriter = writeMembers ? new EventWriter(normalTypeNameWriter) : new EmptyEventWriter(); return(new PlantUmlTypeWriter( queryType, normalTypeNameWriter, escapedTypeNameWriter, eventWriter, methodWriter, fieldWriter, propertyWriter)); }
public async Task SetMappedValuesAsync([NotNull] IDeferredItem <TItem> deferredItem, [NotNull] RestItemData itemData) { foreach (KeyValuePair <string, object> kvp in itemData) { if (!_fieldProvider.FieldExists(kvp.Key)) { throw new FieldNotFoundException(kvp.Key, false); } IFieldWriter <TItem> fieldWriter = _fieldProvider.GetWriter(kvp.Key); if (fieldWriter == null) { throw new FieldOperationNotAllowedException(kvp.Key, FieldOperation.Write); } var namedField = new NamedField <TItem>(kvp.Key, _fieldProvider); if (!_authChecker.CanEditField(deferredItem, namedField)) { throw new NotAuthorizedForFieldException(AuthorizableVerb.Edit, kvp.Key); } await fieldWriter.SetValueAsync(deferredItem, kvp.Value, _dataTransaction); } }
private void WriteDefinitionForThisLevel(IFieldWriter writer) { if (m_BasePacket != null) { m_BasePacket.WriteDefinitionForThisLevel(writer); } writer.Write(m_TypeName); writer.Write(m_Version); writer.Write(m_Fields.Count); foreach (FieldDefinition fieldDefinition in m_Fields) { writer.Write(fieldDefinition.Name); writer.Write((int)fieldDefinition.FieldType); } // Writer out any associated sub-packets writer.Write(m_SubPackets.Count); for (int i = 0; i < m_SubPackets.Count; i++) { m_SubPackets[i].WriteDefinition(writer); } }
internal abstract void Write(IFieldWriter writer);
internal override void Write(IFieldWriter writer) { writer.WriteValueU32(this._Value1); writer.WriteValueF32(this._Value2); }
/// <summary> /// This helper method uses reflection to invoke the proper method to write /// a value to the stream of type T. /// </summary> private void WriteValue(IFieldWriter writer, T value) { m_WriteMethod.Invoke(writer, new object[] { value }); }
/// <summary> /// Writes an array of type T to the stream. /// </summary> /// <param name="array">Data to be written</param> /// <param name="writer">Stream to write the data into</param> public void Write(T[] array, IFieldWriter writer) { writer.Write((UInt32)array.Length); int currentIndex = 0; int peekIndex = currentIndex + 1; int runLength = 0; // iterate across the array writing out a series of "runs" in which each // run is either a repetition of the same value or a sequence of unique values. while (currentIndex < array.Length) { // check for the end of the array if (peekIndex < array.Length) { // is this the start of a new run? if (runLength == 0) { // is this a run or repeated values? if (AreEqual(array[peekIndex], array[peekIndex - 1])) { // since the first two values match, we know we have a run of at least 2 repeating values runLength = 2; } else { // if the first two values differ, we have a run of at least 1 unique value runLength = -1; } peekIndex += 1; } else if (runLength > 0) { // is the run of repeating values continuing? if (AreEqual(array[peekIndex], array[peekIndex - 1])) { runLength += 1; peekIndex += 1; } else { WriteRun(array, writer, ref runLength, ref currentIndex, ref peekIndex); } } else // runLength < 0 { // is the run of unique values continuing? if (!AreEqual(array[peekIndex], array[peekIndex - 1])) { runLength -= 1; // we decrement because we're accumulating a negative length peekIndex += 1; } else { // don't include the last value because it is part of the next (repeating) run WriteRun(array, writer, ref runLength, ref currentIndex, ref peekIndex); } } } else { WriteRun(array, writer, ref runLength, ref currentIndex, ref peekIndex); } } }
internal override void Write(IFieldWriter writer) { writer.WriteValueF32(this.Version); writer.WriteValueS32(this.RecordCount); writer.WriteValueU32(this.NextRecordId); }
internal override void Write(IFieldWriter writer) { writer.WriteValueU32(this._Value1 == true ? 1u : 0u); writer.WriteValueU32(this._Value2 == true ? 1u : 0u); }