/// <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);
}
