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>
/// 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);
}
public static IDictionary <string, IFieldReader <TItem> > GetReaders <TItem>(this IFieldProvider <TItem> fieldProvider, [NotNull] IEnumerable <string> fieldNames)
where TItem : class
{
if (fieldProvider == null)
{
throw new ArgumentNullException(nameof(fieldProvider));
}
if (fieldNames == null)
{
throw new ArgumentNullException(nameof(fieldNames));
}
var dict = new Dictionary <string, IFieldReader <TItem> >();
foreach (string fieldName in fieldNames)
{
if (!fieldProvider.FieldExists(fieldName))
{
throw new FieldNotFoundException(fieldName, false);
}
IFieldReader <TItem> reader = fieldProvider.GetReader(fieldName);
if (reader == null)
{
throw new FieldOperationNotAllowedException(fieldName, FieldOperation.Read);
}
dict.Add(fieldName, reader);
}
return(dict);
}
internal static IdAndFloatValue Read(IFieldReader reader)
{
var value1 = reader.ReadValueU32();
var value2 = reader.ReadValueF32();
return(new IdAndFloatValue(value1, value2));
}
/// <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 static IntValue Read(IFieldReader reader)
{
var value1 = reader.ReadValueS32();
var value2 = reader.ReadValueS32();
return(new IntValue(value1, value2));
}
internal static EnumValue Read(IFieldReader reader)
{
var value1 = reader.ReadValueU32();
var value2 = reader.ReadValueU32();
return(new EnumValue(value1, value2));
}
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>
/// This is the method that is invoked on an IPacketFactory to create an IPacket
/// from the data in an IFieldReader given a specified PacketDefinition.
/// </summary>
/// <param name="definition">Definition of the fields expected in the next packet</param>
/// <param name="reader">Data stream to be read</param>
/// <returns>An IPacket corresponding to the PacketDefinition and the stream data</returns>
public IPacket CreatePacket(PacketDefinition definition, IFieldReader reader)
{
IPacket packet = (IPacket)m_Constructor.Invoke(new object[0]);
definition.ReadFields(packet, reader);
return(packet);
}
/// <summary>
/// This is the method that is invoked on an IPacketFactory to create an IPacket
/// from the data in an IFieldReader given a specified PacketDefinition.
/// </summary>
/// <param name="definition">Definition of the fields expected in the next packet</param>
/// <param name="reader">Data stream to be read</param>
/// <returns>An IPacket corresponding to the PacketDefinition and the stream data</returns>
public IPacket CreatePacket(PacketDefinition definition, IFieldReader reader)
{
IPacket packet;
//what we create varies by what specific definition they're looking for
if (definition.TypeName == m_ThreadInfoPacketType)
{
packet = new ThreadInfoPacket();
}
else if (definition.TypeName == m_SessionStartInfoPacketType)
{
packet = new SessionSummaryPacket();
}
else if (definition.TypeName == m_SessionEndInfoPacketType)
{
packet = new SessionClosePacket();
}
else if (definition.TypeName == m_SessionFilePacketType)
{
packet = new SessionFragmentPacket();
}
else
{
//crap, we don't know what to do here.
throw new ArgumentOutOfRangeException(nameof(definition), definition.TypeName, "This packet factory doesn't understand how to create packets for the provided type.");
}
//this feels a little crazy, but you have to do your own read call here - we aren't just creating the packet
//object, we actually have to make the standard call to have it read data...
definition.ReadFields(packet, reader);
return(packet);
}
public SimpleDataColumn(string column, IFieldReader reader)
: base(column)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
m_reader = reader;
}
public SimpleDataColumn(string column, IFieldReader reader)
: base(column)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
m_reader = reader;
}
internal static BoolValue Read(IFieldReader reader)
{
var value1 = reader.ReadValueB8();
reader.SkipBytes(3);
var value2 = reader.ReadValueB8();
reader.SkipBytes(3);
return(new BoolValue(value1, value2));
}
public void ReadFields(IPacket packet, IFieldReader reader)
{
IDynamicPacket dynamicPacket = packet as IDynamicPacket;
if (dynamicPacket != null)
{
dynamicPacket.DynamicTypeName = m_DynamicTypeName;
}
ReadFields(packet.GetType(), packet, reader);
}
public ItemRespository(IItemCreator itemCreator, IMediaReader mediaReader, IFieldReader fieldReader, IAuditCreator auditCreator, IItemReader itemReader, IItemUpdater itemUpdater, IAuditReader auditReader)
{
_itemCreator = itemCreator;
_mediaReader = mediaReader;
_fieldReader = fieldReader;
_auditCreator = auditCreator;
_itemReader = itemReader;
_itemUpdater = itemUpdater;
_auditReader = auditReader;
}
public MemberInitExpression Build <TItem>(ParameterExpression itemPram, IFieldProvider <TItem> fieldProvider)
where TItem : class
{
return(Build(delegate(FieldInfo fi)
{
IFieldReader <TItem> reader = fieldProvider.GetReader(fi.Name);
Debug.Assert(reader != null, "Reader should definitely not be null here.");
return Expression.Bind(fi, reader.GetSelectExpression(itemPram));
}));
}
public MemberInitExpression Build <TItem>(ParameterExpression itemPram, IDictionary <string, IFieldReader <TItem> > fieldReaders)
where TItem : class
{
return(Build(delegate(FieldInfo fi)
{
Debug.Assert(fieldReaders.ContainsKey(fi.Name));
IFieldReader <TItem> reader = fieldReaders[fi.Name];
return Expression.Bind(fi, reader.GetSelectExpression(itemPram));
}));
}
/// <summary>
/// Creates a new parser using the given <see cref="FieldReader"/>.
/// </summary>
/// <param name="fieldReader">The field reader.</param>
public CsvParser(IFieldReader fieldReader)
{
//this.fieldReader = fieldReader ?? throw new ArgumentNullException( nameof( fieldReader ) );
this.fieldReader = CSharp6Extension.GetArgumentOrThrowException <IFieldReader>(fieldReader, nameof(fieldReader));
//context = fieldReader.Context as ReadingContext ?? throw new InvalidOperationException( $"For {nameof( FieldReader )} to be used in {nameof( CsvParser )}, {nameof( FieldReader.Context )} must also implement {nameof( ReadingContext )}." );
context = fieldReader.Context as ReadingContext;
if (context == null)
{
throw new InvalidOperationException($"For {nameof( FieldReader )} to be used in {nameof( CsvParser )}, {nameof( FieldReader.Context )} must also implement {nameof( ReadingContext )}.");
}
}
private static T GetField <T>(IFieldReader <T> reader, IDataRecord record, int recordIndex, IMappingField mappingField)
{
try
{
return(reader.GetField(record, recordIndex));
}
catch (Exception e)
{
var message = String.Format("Could not read {0} of row {1}: {2}. It looks like the data for the {0} is incorrect. If you are importing data from Excel, please check the mapping for this column and try again.",
mappingField.UserFriendlyName, recordIndex, e.Message);
throw new SqlDataFormatUnexpectedException(message, e);
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <param name="disposing">True if the instance needs to be disposed of.</param>
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
fieldReader?.Dispose();
}
fieldReader = null;
context = null;
disposed = true;
}
public IFieldWriter <TItem> GetWriter(string fieldName)
{
if (_implementations.WriterFactories.ContainsKey(fieldName))
{
return(_implementations.WriterFactories[fieldName].Get(_stem));
}
IFieldReader <TItem> reader = GetReader(fieldName);
if (reader != null)
{
return(new ConfirmOnlyFieldWriter <TItem>(fieldName, reader));
}
return(null);
}
internal static Property Read(IFieldReader reader)
{
var valueType = (ValueType)reader.ReadValueU8(); // & 7
reader.SkipBytes(3);
var function = (FunctionType)reader.ReadValueU8(); // & 3
reader.SkipBytes(3);
var index = reader.ReadValueU16(); // & 0x7FF
reader.SkipBytes(2);
var value = ReadValue(valueType, reader);
var factor = reader.Version >= 88 ? reader.ReadValueF32() : 0;
return(new Property(index, function, value, factor));
}
internal static ConditionData Read(IFieldReader reader)
{
ConditionData instance;
instance.Unknown00 = reader.ReadValueU8();
reader.SkipBytes(3);
instance.Unknown04 = reader.ReadValueU32();
instance.Unknown08 = reader.ReadValueU16();
reader.SkipBytes(2);
instance.Unknown0C = reader.ReadValueU32();
instance.Unknown10 = reader.ReadValueU32();
instance.Unknown14 = reader.ReadValueU8();
reader.SkipBytes(3);
instance.Unknown18 = reader.ReadValueU32();
instance.Unknown1C = reader.ReadValueU32();
return(instance);
}
/// <summary>
/// This is the method that is invoked on an IPacketFactory to create an IPacket
/// from the data in an IFieldReader given a specified PacketDefinition.
/// </summary>
/// <param name="definition">Definition of the fields expected in the next packet</param>
/// <param name="reader">Data stream to be read</param>
/// <returns>An IPacket corresponding to the PacketDefinition and the stream data</returns>
public IPacket CreatePacket(PacketDefinition definition, IFieldReader reader)
{
IPacket packet;
//what we create varies by what specific definition they're looking for
if (definition.TypeName == m_LogMessagePacketType)
{
var logPacket = new LogMessagePacket(m_SessionPacketCache);
packet = logPacket;
if (!ReferenceEquals(definition, m_CachedLogMessagePacketDefinition))
{
var currentDefinition = PacketDefinition.CreatePacketDefinition(packet);
m_UseFastDeserialization = definition.Equals(currentDefinition);
m_CachedLogMessagePacketDefinition = definition;
}
if (m_UseFastDeserialization)
{
logPacket.ReadFieldsFast(reader);
}
else
{
definition.ReadFields(packet, reader);
}
}
else if (definition.TypeName == m_ExceptionInfoPacketType)
{
packet = new ExceptionInfoPacket();
definition.ReadFields(packet, reader);
}
else if (definition.TypeName == m_ApplicationUserPacketType)
{
packet = new ApplicationUserPacket();
definition.ReadFields(packet, reader);
}
else
{
//crap, we don't know what to do here.
throw new ArgumentOutOfRangeException(nameof(definition), definition.TypeName, "This packet factory doesn't understand how to create packets for the provided type.");
}
return(packet);
}
public TransactionFieldReader(
IFieldReader <string> idColumn,
IFieldReader <string> usernameColumn,
IFieldReader <DateTime> dateColumn,
IFieldReader <string> nominalCodeColumn,
IFieldReader <double> amountColumn,
IFieldReader <string> descriptionColumn,
IFieldReader <string> typeColumn,
IFieldReader <string> nominalCodeNameColumn)
{
this.idColumn = idColumn;
this.usernameColumn = usernameColumn;
this.dateColumn = dateColumn;
this.nominalCodeColumn = nominalCodeColumn;
this.amountColumn = amountColumn;
detailsColumn = descriptionColumn;
this.typeColumn = typeColumn;
this.nominalCodeNameColumn = nominalCodeNameColumn;
}
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;
}
}
}
/// <summary>
/// Loads a single scalar field reader from a single <see cref="itemQuery"/>.
/// </summary>
public static async Task <object> LoadScalarValueAsync <TItem>([NotNull] IFieldReader <TItem> reader, IQueryableSingle <TItem> itemQuery, ForEachAsyncDelegate <object> forEachAsync)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
ParameterExpression itemPram = Expression.Parameter(typeof(TItem), "itm");
Expression selectExpression = reader.GetSelectExpression(itemPram);
IQueryable selectScalarOnlyQuery = ExpressionTreeHelpers.GetSelectExpressionQuery(itemQuery, itemPram, selectExpression);
object loadedValue = await ItemQueryHelper.SingleOrCreateAsync(selectScalarOnlyQuery, forEachAsync, () => throw new ParentItemNotFoundException());
if (reader.Replacer != null)
{
await reader.Replacer.LoadAsync(itemQuery);
return(reader.Replacer.GetReplacement(loadedValue));
}
return(loadedValue);
}
/// <summary>
/// Reads an array of type T from the stream.
/// </summary>
/// <param name="reader">Data stream to read</param>
/// <returns>Array of type T</returns>
public T[] Read(IFieldReader reader)
{
// The array always starts with its length. Since the length can't be
// negative we pass it unsigned (which gives slightly better compression)
int length = (int)reader.ReadUInt32();
T[] array = new T[length];
// The array values are stored as a seuqnece of runs. Each run represents
// either a sequence of repeating values or a sequence of unique values.
int index = 0;
while (index < length)
{
int runLength = reader.ReadInt32();
if (runLength > 0)
{
// a positive runLength indicates a run of repeating values.
// So, we only need to store the actual value once.
T value = ReadValue(reader);
for (int i = 0; i < runLength; i++)
{
array[index++] = value;
}
}
else // runLength < 0
{
// a negative runLength indicates a run of unique values
for (int i = runLength; i < 0; i++)
{
// in this case, we need to store each value
T value = ReadValue(reader);
array[index++] = value;
}
}
}
return(array);
}
public IPacket CreatePacket(PacketDefinition definition, IFieldReader reader)
{
IPacket packet;
if (definition.TypeName == m_SampledMetricDefinitionPacketType)
{
//sampled metrics can't be created directly - they're an abstract class.
throw new ArgumentOutOfRangeException(nameof(definition), definition.TypeName, "Sampled Metric objects can't be created, only derived classes can.");
}
//what we create varies by what specific definition they're looking for
if (definition.TypeName == m_MetricDefinitionPacketType)
{
packet = new MetricDefinitionPacket(m_Session);
}
else if (definition.TypeName == m_EventMetricDefinitionPacketType)
{
packet = new EventMetricDefinitionPacket(m_Session);
}
else if (definition.TypeName == m_EventMetricValueDefinitionPacketType)
{
packet = new EventMetricValueDefinitionPacket(m_Session);
}
else if (definition.TypeName == m_CustomSampledMetricDefinitionPacketType)
{
packet = new CustomSampledMetricDefinitionPacket(m_Session);
}
else
{
//crap, we don't know what to do here.
throw new ArgumentOutOfRangeException(nameof(definition), definition.TypeName, "This packet factory doesn't undersatnd how to create packets for the provided type.");
}
//this feels a little crazy, but you have to do your own read call here - we aren't just creating the packet
//object, we actually have to make the standard call to have it read data...
definition.ReadFields(packet, reader);
return(packet);
}
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 RegisterField(IFieldReader fieldOptions, ITextExtractor defaultTextExtractor, ITokenizer defaultTokenizer)
{
var fieldName = fieldOptions.Name;
if (this.fieldToDetailsLookup.ContainsKey(fieldOptions.Name))
{
throw new LiftiException(ExceptionMessages.FieldNameAlreadyUsed, fieldName);
}
var newId = Interlocked.Increment(ref nextId);
if (newId > byte.MaxValue)
{
throw new LiftiException(ExceptionMessages.MaximumDistinctFieldsIndexReached);
}
var id = (byte)newId;
var fieldTokenizer = fieldOptions.Tokenizer ?? defaultTokenizer;
var textExtractor = fieldOptions.TextExtractor ?? defaultTextExtractor;
this.fieldToDetailsLookup[fieldName] = new IndexedFieldDetails((byte)id, textExtractor, fieldTokenizer);
this.idToFieldLookup[id] = fieldName;
}
public SimpleDataColumn(string column, IFieldReader reader, int index)
: base(column)
{
m_reader = reader;
m_index = index;
}
