private PacketDefinition(IFieldReader reader)
{
m_TypeName = reader.ReadString();
m_Version = reader.ReadInt32();
int fieldCount = reader.ReadInt32();
for (int i = 0; i < fieldCount; i++)
{
string fieldName = reader.ReadString();
FieldType fieldType = (FieldType)reader.ReadInt32();
m_Fields.Add(new FieldDefinition(fieldName, fieldType));
}
// Handle the possiblity that a Packet aggregates lower level packets
int subPacketCount = reader.ReadInt32();
m_SubPackets = new List <PacketDefinition>();
for (int i = 0; i < subPacketCount; i++)
{
// We need to call the static ReadPacketDefinition(reader) in order to
// read and process the cacheable, version, and dynamic name fields which
// also exist for each subPacket definition. Fixed as part of Case #165
PacketDefinition subPacket = ReadPacketDefinition(reader);
m_SubPackets.Add(subPacket);
}
}
/// <summary>
/// Optimized deserialization of a LogMessagePacket based on the current packet definition
/// </summary>
public new void ReadFieldsFast(IFieldReader reader)
{
base.ReadFieldsFast(reader);
m_ID = reader.ReadGuid();
m_Caption = reader.ReadString();
m_Severity = (LogMessageSeverity)reader.ReadInt32();
m_LogSystem = reader.ReadString();
m_CategoryName = reader.ReadString();
m_UserName = reader.ReadString();
m_Description = reader.ReadString();
m_Details = reader.ReadString();
m_ThreadIndex = reader.ReadInt32();
m_ThreadId = reader.ReadInt32();
m_MethodName = reader.ReadString();
m_ClassName = reader.ReadString();
m_FileName = reader.ReadString();
m_LineNumber = reader.ReadInt32();
string[] typeNames = reader.ReadStringArray();
string[] messages = reader.ReadStringArray();
string[] sources = reader.ReadStringArray();
string[] stackTraces = reader.ReadStringArray();
Guid applicationUserId = reader.ReadGuid();
if (m_ThreadIndex == 0)
{
m_ThreadIndex = m_ThreadId; // Zero isn't legal, so it must not have had it. Fall back to ThreadId.
}
if (applicationUserId != Guid.Empty)
{
ApplicationUser applicationUser;
m_SessionPacketCache.Users.TryGetValue(applicationUserId, out applicationUser);
UserPacket = applicationUser.Packet;
}
//these are supposed to be parallel arrays - assume they're all the same size.
int arrayLength = typeNames.GetLength(0);
var exceptions = new IExceptionInfo[arrayLength]; // local holder to build it up
IExceptionInfo lastException = null;
for (int i = 0; i < arrayLength; i++)
{
IExceptionInfo exception = new ExceptionInfoPacket()
{
TypeName = typeNames[i],
Message = messages[i],
Source = sources[i],
StackTrace = stackTraces[i],
};
exceptions[i] = exception;
if (lastException != null)
{
((ExceptionInfoPacket)lastException).InnerException = exception; //we are the inner exception to our parent.
}
lastException = exception;
}
m_ExceptionChain = exceptions; // Set the rehydrated ExceptionInfo[] array property
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.FULL:
{
this.MarkField(1);
this._FullName = reader.ReadLocalizedString();
break;
}
case FieldType.LNAM:
{
this._Ids.Add(reader.ReadValueU32());
break;
}
default:
{
throw new NotSupportedException();
}
}
}
/// <summary>
/// Returns a PacketDefinition from the stream (including nested PacketDefinition
/// objects for cases in which an IPacket is subclassed and has serialized state
/// at multiple levels).
/// </summary>
/// <param name="reader">Stream to read data from</param>
/// <returns>PacketDefinition (including nested definitions for subclassed packets)</returns>
public static PacketDefinition ReadPacketDefinition(IFieldReader reader)
{
bool cachedPacket = reader.ReadBool();
int nestingDepth = reader.ReadInt32();
if (nestingDepth < 1)
{
throw new GibraltarException(string.Format(CultureInfo.InvariantCulture, "While reading the definition of the next packet, the number of types in the definition was read as {0} which is less than 1.", nestingDepth));
}
string dynamicTypeName = reader.ReadString();
PacketDefinition[] definitions = new PacketDefinition[nestingDepth];
for (int i = 0; i < nestingDepth; i++)
{
definitions[i] = new PacketDefinition(reader);
if (i > 0)
{
definitions[i].m_BasePacket = definitions[i - 1];
}
}
PacketDefinition topLevelDefinition = definitions[nestingDepth - 1];
topLevelDefinition.m_IsCachable = cachedPacket;
topLevelDefinition.m_DynamicTypeName = dynamicTypeName;
return(topLevelDefinition);
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.BNAM:
{
this._BaseNames.Add(reader.ReadString(260));
break;
}
case FieldType.SNAM:
{
this._SwapNames.Add(reader.ReadString(260));
break;
}
case FieldType.FNAM:
{
this._FNAM.Add(reader.ReadString(260));
break;
}
case FieldType.CNAM:
{
this._CNAM.Add(reader.ReadValueU32());
break;
}
}
}
private void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this._EditorId = reader.ReadString(size);
break;
}
default:
{
this._Fields.Add(new Tuple <uint, byte[]>(type, reader.ReadBytes(size)));
break;
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.FULL:
{
this.MarkField(1);
this._FullName = reader.ReadLocalizedString();
break;
}
case FieldType.DESC:
{
this.MarkField(2);
this._Description = reader.ReadLocalizedString();
break;
}
case FieldType.MODL:
{
this.MarkField(3);
break;
}
case FieldType.MODT:
{
this.MarkField(4);
break;
}
case FieldType.DATA:
{
this.MarkField(5);
this._Data = reader.ReadObject <ObjectMod.Data>();
break;
}
case FieldType.MNAM:
{
this.MarkField(6);
Debug.Assert(size > 0 && (size % 4) == 0);
var keywordIds = new uint[size / 4];
for (int i = 0; i < keywordIds.Length; i++)
{
keywordIds[i] = reader.ReadValueU32();
}
this._KeywordIds.Clear();
this._KeywordIds.AddRange(keywordIds);
break;
}
case FieldType.LNAM:
{
this.MarkField(7);
Debug.Assert(size == 4);
this._LNAM = reader.ReadValueU32();
break;
}
case FieldType.NAM1:
{
this.MarkField(8);
break;
}
case FieldType.FLTR:
{
this.MarkField(9);
this._EditorFilter = reader.ReadString(260);
break;
}
case FieldType.FNAM:
{
this.MarkField(10);
break;
}
case FieldType.MODS:
{
this.MarkField(11);
break;
}
default:
{
throw new NotSupportedException();
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.FULL:
{
this._FullName = reader.ReadLocalizedString();
break;
}
case FieldType.DESC:
{
this.MarkField(2);
this._Description = reader.ReadLocalizedString();
break;
}
case FieldType.OBND:
{
this.MarkField(3);
Debug.Assert(size == 12);
break;
}
case FieldType.PTRN:
{
this.MarkField(4);
Debug.Assert(size == 4);
break;
}
case FieldType.MOD2:
{
this.MarkField(5);
this._ModelMale = reader.ReadString(260);
break;
}
case FieldType.MO2T:
{
this.MarkField(6);
break;
}
case FieldType.BOD2:
{
this.MarkField(7);
Debug.Assert(size == 4);
break;
}
case FieldType.RNAM:
{
this.MarkField(8);
Debug.Assert(size == 4);
break;
}
case FieldType.KSIZ:
{
this.MarkField(9);
Debug.Assert(size == 4);
break;
}
case FieldType.KWDA:
{
this.MarkField(10);
break;
}
case FieldType.INRD:
{
this.MarkField(11);
Debug.Assert(size == 4);
break;
}
case FieldType.INDX:
{
//this.MarkField(12);
Debug.Assert(size == 2);
break;
}
case FieldType.MODL:
{
//this.MarkField(13);
Debug.Assert(size == 4);
break;
}
case FieldType.DATA:
{
this.MarkField(14);
Debug.Assert(size == 12);
break;
}
case FieldType.FNAM:
{
this.MarkField(15);
Debug.Assert(size == 8);
break;
}
case FieldType.DAMA:
{
this.MarkField(16);
Debug.Assert(size == 8 || size == 16);
break;
}
case FieldType.APPR:
{
this.MarkField(17);
Debug.Assert(size == 4 || size == 8 || size == 16 || size == 28);
break;
}
case FieldType.OBTE:
{
this.MarkField(18);
Debug.Assert(size == 4);
break;
}
case FieldType.OBTS:
{
//this.MarkField(19);
//0x32 0x1D
break;
}
case FieldType.OBTF:
{
//this.MarkField(20);
Debug.Assert(size == 0);
break;
}
case FieldType.STOP:
{
this.MarkField(21);
Debug.Assert(size == 0);
break;
}
case FieldType.EITM:
{
this.MarkField(22);
Debug.Assert(size == 4);
break;
}
case FieldType.MOD4:
{
this.MarkField(23);
this._ModelFemale = reader.ReadString(260);
break;
}
case FieldType.MO4T:
{
this.MarkField(24);
break;
}
case FieldType.ETYP:
{
this.MarkField(25);
Debug.Assert(size == 4);
break;
}
case FieldType.MO2S:
{
this.MarkField(26);
Debug.Assert(size == 4);
break;
}
case FieldType.YNAM:
{
this.MarkField(27);
Debug.Assert(size == 4);
break;
}
case FieldType.ZNAM:
{
this.MarkField(28);
Debug.Assert(size == 4);
break;
}
case FieldType.MO4S:
{
this.MarkField(29);
Debug.Assert(size == 4);
break;
}
case FieldType.VMAD:
{
this.MarkField(30);
break;
}
case FieldType.BAMT:
{
this.MarkField(31);
Debug.Assert(size == 4);
break;
}
default:
{
throw new NotSupportedException();
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.FULL:
{
this.MarkField(1);
this._FullName = reader.ReadLocalizedString();
break;
}
case FieldType.DESC:
{
this.MarkField(2);
this._Description = reader.ReadLocalizedString();
break;
}
case FieldType.OBND:
{
this.MarkField(3);
Debug.Assert(size == 12);
break;
}
case FieldType.MODL:
{
this.MarkField(4);
this._Model = reader.ReadString(0);
break;
}
case FieldType.MODT:
{
this.MarkField(5);
break;
}
case FieldType.DNAM:
{
this.MarkField(6);
Debug.Assert((reader.Version >= 107 && size == 16) || (reader.Version < 107 && size == 8));
var value1 = reader.ReadValueF32();
var value2 = reader.ReadValueU32();
if (reader.Version >= 107)
{
var value3 = reader.ReadValueF32();
var value4 = reader.ReadValueF32();
}
else
{
}
break;
}
case FieldType.MNAM:
{
this.MarkField(7);
Debug.Assert(size == 1040);
break;
}
case FieldType.PRPS:
{
this.MarkField(8);
//Assert(size == 8);
break;
}
case FieldType.PTRN:
{
this.MarkField(9);
Debug.Assert(size == 4);
break;
}
case FieldType.MODS:
{
this.MarkField(10);
Debug.Assert(size == 4);
break;
}
case FieldType.NVNM:
{
this.MarkField(11);
//Assert(size == 720);
break;
}
case FieldType.MODC:
{
this.MarkField(12);
Debug.Assert(size == 4);
break;
}
case FieldType.VMAD:
{
this.MarkField(13);
Debug.Assert(size == 36);
break;
}
case FieldType.FTYP:
{
this.MarkField(14);
Debug.Assert(size == 4);
break;
}
default:
{
throw new NotSupportedException();
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.FULL:
{
this._FullName = reader.ReadLocalizedString();
break;
}
case FieldType.CNAM:
{
this.MarkField(2);
Debug.Assert(size == 4);
this._CNAM = reader.ReadValueU32();
break;
}
case FieldType.TNAM:
{
this.MarkField(3);
Debug.Assert(size == 4);
this._TNAM = reader.ReadValueU32();
break;
}
case FieldType.DNAM:
{
this.MarkField(4);
this._DNAM = reader.ReadString(0);
break;
}
case FieldType.DATA:
{
this.MarkField(5);
Debug.Assert(size == 4);
this._DATA = reader.ReadValueU32();
break;
}
case FieldType.NNAM:
{
this.MarkField(6);
this._NNAM = reader.ReadString(260);
break;
}
default:
{
throw new NotSupportedException();
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((Fields)type)
{
case Fields.HEDR:
{
this.MarkField(0);
Debug.Assert(size == 12);
this._Header = reader.ReadObject <PluginHeader>();
break;
}
case Fields.CNAM:
{
this.MarkField(1);
this._Creator = reader.ReadString(size);
break;
}
case Fields.SNAM:
{
this.MarkField(2);
this._Summary = reader.ReadString(size);
break;
}
case Fields.MAST:
{
this._Masters.Add(reader.ReadString(size));
break;
}
case Fields.DATA:
{
break;
}
case Fields.TNAM:
{
break;
}
case Fields.INTV:
{
this.MarkField(6);
Debug.Assert(size == 4);
break;
}
case Fields.INCC:
{
this.MarkField(7);
Debug.Assert(size == 4);
break;
}
default:
{
throw new NotSupportedException();
}
}
}
internal override void ReadField(uint type, IFieldReader reader)
{
var size = reader.Size;
switch ((FieldType)type)
{
case FieldType.EDID:
{
this.MarkField(0);
this._EditorId = reader.ReadString(size);
break;
}
case FieldType.DESC:
{
this.MarkField(1);
this._Description = reader.ReadLocalizedString();
break;
}
case FieldType.FVPA:
{
this.MarkField(2);
Debug.Assert(size > 0 && (size % 8) == 0);
var ingredients = new Ingredient[size / 8];
for (int i = 0; i < ingredients.Length; i++)
{
var inputId = reader.ReadValueU32();
var quantity = reader.ReadValueS32();
ingredients[i] = new Ingredient(inputId, quantity);
}
this._Ingredients.Clear();
this._Ingredients.AddRange(ingredients);
break;
}
case FieldType.CTDA:
{
Debug.Assert(size == 32);
this._Conditions.Add(ConditionData.Read(reader));
break;
}
case FieldType.CNAM:
{
this.MarkField(4);
Debug.Assert(size == 4);
this._OutputId = reader.ReadValueU32();
break;
}
case FieldType.INTV:
{
this.MarkField(5);
if (size == 4)
{
this._OutputCount = reader.ReadValueU32();
}
else if (size == 2)
{
this._OutputCount = reader.ReadValueU16();
}
else
{
throw new FormatException();
}
break;
}
case FieldType.BNAM:
{
this.MarkField(6);
Debug.Assert(size == 4);
this._BenchKeywordId = reader.ReadValueU32();
break;
}
case FieldType.FNAM:
{
this.MarkField(7);
Debug.Assert(size > 0 && (size % 4) == 0);
var ids = new uint[size / 4];
for (int i = 0; i < ids.Length; i++)
{
ids[i] = reader.ReadValueU32();
}
this._FilterKeywordIds.Clear();
this._FilterKeywordIds.AddRange(ids);
break;
}
case FieldType.YNAM:
{
this.MarkField(8);
Debug.Assert(size == 4);
this._PickupSoundId = reader.ReadValueU32();
break;
}
case FieldType.ZNAM:
{
this.MarkField(9);
Debug.Assert(size == 4);
this._PutdownSoundId = reader.ReadValueU32();
break;
}
case FieldType.ANAM:
{
this.MarkField(11);
Debug.Assert(size == 4);
this._ArtId = reader.ReadValueU32();
break;
}
case FieldType.NAM1:
case FieldType.NAM2:
case FieldType.NAM3:
{
// deprecated
break;
}
default:
{
throw new NotSupportedException();
}
}
}
/// <summary>
/// Read any packet based solely on its PacketDefinition
/// </summary>
/// <param name="definition">PacketDefinition describing the next packet in the stream</param>
/// <param name="reader">Data stream to be read</param>
public GenericPacket(PacketDefinition definition, IFieldReader reader)
{
if (definition.BasePacket != null)
{
m_BasePacket = new GenericPacket(definition.BasePacket, reader);
}
m_Definition = definition;
m_FieldValues = new object[definition.Fields.Count];
for (int index = 0; index < definition.Fields.Count; index++)
{
switch (definition.Fields[index].FieldType)
{
case FieldType.Bool:
m_FieldValues[index] = reader.ReadBool();
break;
case FieldType.BoolArray:
m_FieldValues[index] = reader.ReadBoolArray();
break;
case FieldType.String:
m_FieldValues[index] = reader.ReadString();
break;
case FieldType.StringArray:
m_FieldValues[index] = reader.ReadStringArray();
break;
case FieldType.Int32:
m_FieldValues[index] = reader.ReadInt32();
break;
case FieldType.Int32Array:
m_FieldValues[index] = reader.ReadInt32Array();
break;
case FieldType.Int64:
m_FieldValues[index] = reader.ReadInt64();
break;
case FieldType.Int64Array:
m_FieldValues[index] = reader.ReadInt64Array();
break;
case FieldType.UInt32:
m_FieldValues[index] = reader.ReadUInt32();
break;
case FieldType.UInt32Array:
m_FieldValues[index] = reader.ReadUInt32Array();
break;
case FieldType.UInt64:
m_FieldValues[index] = reader.ReadUInt64();
break;
case FieldType.UInt64Array:
m_FieldValues[index] = reader.ReadUInt64Array();
break;
case FieldType.Double:
m_FieldValues[index] = reader.ReadDouble();
break;
case FieldType.DoubleArray:
m_FieldValues[index] = reader.ReadDoubleArray();
break;
case FieldType.TimeSpan:
m_FieldValues[index] = reader.ReadTimeSpan();
break;
case FieldType.TimeSpanArray:
m_FieldValues[index] = reader.ReadTimeSpanArray();
break;
case FieldType.DateTime:
m_FieldValues[index] = reader.ReadDateTime();
break;
case FieldType.DateTimeArray:
m_FieldValues[index] = reader.ReadDateTimeArray();
break;
case FieldType.Guid:
m_FieldValues[index] = reader.ReadGuid();
break;
case FieldType.GuidArray:
m_FieldValues[index] = reader.ReadGuidArray();
break;
case FieldType.DateTimeOffset:
m_FieldValues[index] = reader.ReadDateTimeOffset();
break;
case FieldType.DateTimeOffsetArray:
m_FieldValues[index] = reader.ReadDateTimeOffsetArray();
break;
default:
#if DEBUG
if (Debugger.IsAttached)
{
Debugger.Break();
}
#endif
throw new InvalidOperationException(string.Format("The field type {0} is unknown so we can't deserialize the packet ", definition.Fields[index].FieldType));
}
}
}
