public void ReadingTest()
{
using (var reader = new ReferenceReader(TestFileNames.RefFile))
{
foreach (var row in reader)
{
Assert.IsNotNull(row);
}
}
}
public override Guid Read(Reader reader, int tag)
{
switch (tag)
{
case TagGuid:
return(ReferenceReader.ReadGuid(reader));
case TagBytes:
return(Converter <Guid> .Convert(ReferenceReader.ReadBytes(reader)));
case TagString:
return(Converter <Guid> .Convert(ReferenceReader.ReadString(reader)));
default:
return(base.Read(reader, tag));
}
}
public override TimeSpan Read(Reader reader, int tag)
{
var stream = reader.Stream;
switch (tag)
{
case TagInteger:
return(new TimeSpan(ValueReader.ReadInt(stream)));
case TagLong:
return(new TimeSpan(ValueReader.ReadLong(stream)));
case TagDouble:
return(new TimeSpan((long)ValueReader.ReadDouble(stream)));
case '0':
case TagEmpty:
case TagFalse:
return(TimeSpan.Zero);
case '1':
case TagTrue:
return(new TimeSpan(1));
case TagUTF8Char:
return(Converter <TimeSpan> .Convert(ValueReader.ReadUTF8Char(stream)));
case TagString:
return(Converter <TimeSpan> .Convert(ReferenceReader.ReadString(reader)));
case TagDate:
return(Converter <TimeSpan> .Convert(ReferenceReader.ReadDateTime(reader)));
case TagTime:
return(Converter <TimeSpan> .Convert(ReferenceReader.ReadTime(reader)));
default:
if (tag >= '2' && tag <= '9')
{
return(new TimeSpan(tag - '0'));
}
return(base.Read(reader, tag));
}
}
public override bool Read(Reader reader, int tag)
{
var stream = reader.Stream;
switch (tag)
{
case TagTrue:
return(true);
case TagFalse:
case TagEmpty:
case TagNaN:
case '0':
return(false);
case TagInteger:
return(ValueReader.ReadInt(stream) != 0);
case TagLong:
return(!ValueReader.ReadBigInteger(stream).IsZero);
case TagDouble:
return(ValueReader.ReadDouble(stream) != 0);
case TagUTF8Char:
return("0\0".IndexOf(ValueReader.ReadChar(stream)) == -1);
case TagString:
return(Converter <bool> .Convert(ReferenceReader.ReadString(reader)));
case TagInfinity:
stream.ReadByte();
return(true);
default:
if (tag >= '1' && tag <= '9')
{
return(true);
}
return(base.Read(reader, tag));
}
}
public override BigInteger Read(Reader reader, int tag)
{
if (tag >= '0' && tag <= '9')
{
return(tag - '0');
}
var stream = reader.Stream;
switch (tag)
{
case TagInteger:
return(ValueReader.ReadInt(stream));
case TagLong:
return(ValueReader.ReadBigInteger(stream));
case TagDouble:
return((BigInteger)ValueReader.ReadDouble(stream));
case TagTrue:
return(1);
case TagFalse:
case TagEmpty:
return(0);
case TagUTF8Char:
return(Converter <BigInteger> .Convert(ValueReader.ReadUTF8Char(stream)));
case TagString:
return(Converter <BigInteger> .Convert(ReferenceReader.ReadString(reader)));
case TagDate:
return(Converter <BigInteger> .Convert(ReferenceReader.ReadDateTime(reader)));
case TagTime:
return(Converter <BigInteger> .Convert(ReferenceReader.ReadTime(reader)));
default:
return(base.Read(reader, tag));
}
}
public override double Read(Reader reader, int tag)
{
var stream = reader.Stream;
if (tag >= '0' && tag <= '9')
{
return(tag - '0');
}
switch (tag)
{
case TagDouble:
return(ValueReader.ReadDouble(stream));
case TagInteger:
case TagLong:
return(ValueReader.ReadIntAsDouble(stream));
case TagNaN:
return(double.NaN);
case TagInfinity:
return(ValueReader.ReadInfinity(stream));
case TagTrue:
return(1);
case TagFalse:
case TagEmpty:
return(0);
case TagUTF8Char:
return(Converter <double> .Convert(ValueReader.ReadUTF8Char(stream)));
case TagString:
return(Converter <double> .Convert(ReferenceReader.ReadString(reader)));
default:
return(base.Read(reader, tag));
}
}
public override ArraySegment <T> Read(Reader reader, int tag)
{
switch (tag)
{
case TagList:
return(new ArraySegment <T>(ReferenceReader.ReadArray <T>(reader)));
case TagEmpty:
return(new ArraySegment <T>(empty));
case TagRef:
object obj = reader.ReadReference();
if (obj.GetType().IsArray)
{
return(new ArraySegment <T>((T[])obj));
}
throw new InvalidCastException("Cannot convert " + obj.GetType().ToString() + " to " + typeof(T).ToString() + ".");
default:
return(base.Read(reader, tag));
}
}
static void Main(string[] args)
{
var reader = new ReferenceReader();
var analyser = new ReferenceAnalyser();
var entryAssemblyPath = args[0];
while (string.IsNullOrWhiteSpace(entryAssemblyPath))
{
Console.WriteLine("Enter path to assembly to analyze:");
entryAssemblyPath = Console.ReadLine();
}
string configFilePath;
ConfigurationHelper.TrySuggestConfigFile(entryAssemblyPath, out configFilePath);
var result = reader.Read(entryAssemblyPath);
result = analyser.AnalyzeReferences(result, ConfigurationHelper.GetBindingRedirects(configFilePath));
Console.WriteLine("Select outout mode: C - outout to console, D - output to dgml file");
var mode = Console.ReadKey();
Console.WriteLine();
switch (mode.Key)
{
case ConsoleKey.C:
WriteReferencesToConsole(result);
break;
case ConsoleKey.D:
WriteReferencesToDgmlFile(result);
break;
}
}
public override T Read(Reader reader, int tag)
{
Type type = typeof(T);
if (tag >= '0' && tag <= '9')
{
return((T)Enum.ToObject(type, tag - '0'));
}
var stream = reader.Stream;
switch (tag)
{
case TagInteger:
return((T)Enum.ToObject(type, ValueReader.ReadInt(stream)));
case TagLong:
return((T)Enum.ToObject(type, ValueReader.ReadLong(stream)));
case TagDouble:
return((T)Enum.ToObject(type, (long)ValueReader.ReadDouble(stream)));
case TagTrue:
return((T)Enum.ToObject(type, 1));
case TagFalse:
case TagEmpty:
return((T)Enum.ToObject(type, 0));
case TagUTF8Char:
return((T)Enum.ToObject(type, ValueReader.ReadChar(stream)));
case TagString:
return(Converter <T> .Convert(ReferenceReader.ReadString(reader)));
default:
return(base.Read(reader, tag));
}
}
public override short Read(Reader reader, int tag)
{
return(tag switch
{
'0' => 0,
'1' => 1,
'2' => 2,
'3' => 3,
'4' => 4,
'5' => 5,
'6' => 6,
'7' => 7,
'8' => 8,
'9' => 9,
TagInteger => (short)ValueReader.ReadInt(reader.Stream),
TagLong => (short)ValueReader.ReadLong(reader.Stream),
TagDouble => (short)ValueReader.ReadDouble(reader.Stream),
TagTrue => 1,
TagFalse => 0,
TagEmpty => 0,
TagUTF8Char => Converter <short> .Convert(ValueReader.ReadUTF8Char(reader.Stream)),
TagString => Converter <short> .Convert(ReferenceReader.ReadString(reader)),
_ => base.Read(reader, tag),
});
public override string Read(Reader reader, int tag)
{
var stream = reader.Stream;
switch (tag)
{
case TagString:
return(ReferenceReader.ReadString(reader));
case TagUTF8Char:
return(ValueReader.ReadUTF8Char(stream));
case '0': return("0");
case '1': return("1");
case '2': return("2");
case '3': return("3");
case '4': return("4");
case '5': return("5");
case '6': return("6");
case '7': return("7");
case '8': return("8");
case '9': return("9");
case TagInteger:
case TagLong:
case TagDouble:
return(ValueReader.ReadUntil(stream, TagSemicolon).ToString());
case TagEmpty:
return("");
case TagTrue:
return(bool.TrueString);
case TagFalse:
return(bool.FalseString);
case TagNaN:
return(double.NaN.ToString());
case TagInfinity:
return(ValueReader.ReadInfinity(stream).ToString());
case TagDate:
return(ReferenceReader.ReadDateTime(reader).ToString());
case TagTime:
return(ReferenceReader.ReadTime(reader).ToString());
case TagGuid:
return(ReferenceReader.ReadGuid(reader).ToString());
case TagBytes:
return(Converter <string> .Convert(ReferenceReader.ReadBytes(reader)));
case TagList:
return(Converter <string> .Convert(ReferenceReader.ReadArray <char>(reader)));
default:
return(base.Read(reader, tag));
}
}
private void ReadDataCore(object zRefData)
{
var zReferenceData = zRefData as ProjectLayoutReference[];
var listLines = new List <List <string> >();
var listDefineLines = new List <List <string> >();
var listReferenceDefineLines = new List <List <string> >();
ReferenceReader zRefReader = null;
if (null == zReferenceData || zReferenceData.Length == 0)
{
ReadDefaultProjectDefinitions(listDefineLines);
}
else
{
// 2 per reference + 1 for the project wide defines
m_zReporterProxy.ProgressReset(0, zReferenceData.Length * 2 + 1, 0);
for (int nIdx = 0; nIdx < zReferenceData.Length; nIdx++)
{
var zReference = zReferenceData[nIdx];
var listRefLines = new List <List <string> >();
zRefReader = ReferenceReaderFactory.GetReader(zReference, m_zReporterProxy.ProgressReporter);
if (zRefReader == null)
{
listLines.Clear();
m_zReporterProxy.AddIssue($"Failed to load reference: {zReference.RelativePath}");
break;
}
if (!zRefReader.IsValid())
{
m_zErrorReferenceReader = zRefReader;
listLines.Clear();
m_zReporterProxy.AddIssue($"Reference reader for reference is in an invalid state: {zReference.RelativePath}");
break;
}
var listReferenceActions = new List <Task>();
// 0 index is always the default project reference in the case of multi load
// only load it once
if (nIdx == 0)
{
listReferenceActions.Add(Task.Factory.StartNew(
() =>
{
if (!string.IsNullOrEmpty(ProjectManager.Instance.ProjectFilePath))
{
zRefReader.GetProjectDefineData(zReference, listDefineLines);
if (listDefineLines.Count == 0)
{
m_zReporterProxy.AddIssue("No defines found for project file: {0}".FormatString(ProjectManager.Instance.ProjectFilePath));
}
}
else
{
m_zReporterProxy.AddIssue("No defines loaded for project -- project not yet saved.");
}
m_zReporterProxy.ProgressStep();
}));
}
listReferenceActions.Add(Task.Factory.StartNew(
() =>
{
zRefReader.GetReferenceData(zReference, listRefLines);
m_zReporterProxy.ProgressStep();
}));
listReferenceActions.Add(Task.Factory.StartNew(
() =>
{
zRefReader.GetDefineData(zReference, listReferenceDefineLines);
m_zReporterProxy.ProgressStep();
}));
Task.WaitAll(listReferenceActions.ToArray());
// check if there are existing lines (from prior references) and remove the column header from the latest ref data
if (listLines.Count > 0 && listRefLines.Count > 0)
{
listRefLines.RemoveAt(0);
}
listLines.AddRange(listRefLines);
zRefReader.FinalizeReferenceLoad();
m_zReporterProxy.ProgressStep();
}
}
// Note: the readers trim out the first line for defines data
listDefineLines.AddRange(listReferenceDefineLines);
ProcessLines(
listLines,
listDefineLines,
zReferenceData != null && zReferenceData.Length > 0,
zRefReader?.ReferencePath);
}
private static ReferenceCollection ReadReferences(string fileName)
{
try
{
using (var reader = new ReferenceReader(fileName))
{
return new ReferenceCollection(reader);
}
}
catch (Exception ex)
{
LogWriteLine(ex.Message);
return null;
}
}
public override object Read(Reader reader, int tag)
{
if (tag >= '0' && tag <= '9')
{
return(digitObject[tag - '0']);
}
var stream = reader.Stream;
switch (tag)
{
case TagInteger:
return(ValueReader.ReadInt(stream));
case TagString:
return(ReferenceReader.ReadString(reader));
case TagBytes:
return(ReferenceReader.ReadBytes(reader));
case TagTrue:
return(trueObject);
case TagFalse:
return(falseObject);
case TagEmpty:
return("");
case TagObject:
return(Read(reader));
case TagRef:
return(reader.ReadReference());
case TagDate:
return(ReferenceReader.ReadDateTime(reader));
case TagTime:
return(ReferenceReader.ReadTime(reader));
case TagGuid:
return(ReferenceReader.ReadGuid(reader));
case TagLong:
switch (reader.LongType)
{
case LongType.Int64:
return(ValueReader.ReadLong(stream));
case LongType.UInt64:
return((ulong)ValueReader.ReadLong(stream));
default:
return(ValueReader.ReadBigInteger(stream));
}
case TagDouble:
switch (reader.RealType)
{
case RealType.Single:
return(ValueReader.ReadSingle(stream));
case RealType.Decimal:
return(ValueReader.ReadDecimal(stream));
default:
return(ValueReader.ReadDouble(stream));
}
case TagNaN:
switch (reader.RealType)
{
case RealType.Single:
return(float.NaN);
default:
return(double.NaN);
}
case TagInfinity:
switch (reader.RealType)
{
case RealType.Single:
return(ValueReader.ReadSingleInfinity(stream));
default:
return(ValueReader.ReadInfinity(stream));
}
case TagUTF8Char:
switch (reader.CharType)
{
case CharType.Char:
return(ValueReader.ReadChar(stream));
default:
return(ValueReader.ReadUTF8Char(stream));
}
case TagList:
switch (reader.ListType)
{
case ListType.Array:
return(ReferenceReader.ReadArray <object>(reader));
case ListType.ArrayList:
return(ListDeserializer <ArrayList> .Read(reader));
default:
return(CollectionDeserializer <List <object>, object> .Read(reader));
}
case TagMap:
switch (reader.DictType)
{
case DictType.Dictionary:
return(DictionaryDeserializer <Dictionary <object, object>, object, object> .Read(reader));
case DictType.ExpandoObject:
return(ExpandoObjectDeserializer.Read(reader));
case DictType.Hashtable:
return(DictionaryDeserializer <Hashtable> .Read(reader));
default:
return(DictionaryDeserializer <NullableKeyDictionary <object, object>, object, object> .Read(reader));
}
case TagError:
return(new Exception(reader.Deserialize <string>()));
default:
return(base.Read(reader, tag));
}
}
private void ReadDataCore(object zRefData)
{
var zReferenceData = zRefData as ProjectLayoutReference[];
var listLines = new List <List <string> >();
var listDefineLines = new List <List <string> >();
ReferenceReader zRefReader = null;
if (null == zReferenceData || zReferenceData.Length == 0)
{
ReadDefaultProjectDefinitions(listDefineLines);
}
else
{
WaitDialog.Instance.ProgressReset(0, 0, zReferenceData.Length * 2 + 1, 0);
for (int nIdx = 0; nIdx < zReferenceData.Length; nIdx++)
{
var zReference = zReferenceData[nIdx];
var listRefLines = new List <List <string> >();
zRefReader = ReferenceReaderFactory.GetReader(zReference);
if (zRefReader == null)
{
listLines.Clear();
Logger.AddLogLine($"Failed to load reference: {zReference.RelativePath}");
break;
}
// 0 index is always the default reference in the case of multi load
if (nIdx == 0)
{
if (!string.IsNullOrEmpty(ProjectManager.Instance.ProjectFilePath))
{
zRefReader.GetProjectDefineData(zReference, listDefineLines);
if (listDefineLines.Count == 0)
{
Logger.AddLogLine(
"No defines found for project file: {0}".FormatString(
ProjectManager.Instance.ProjectFilePath));
}
}
else
{
Logger.AddLogLine("No defines loaded for project -- project not yet saved.");
}
WaitDialog.Instance.ProgressStep(0);
}
zRefReader.GetReferenceData(zReference, listRefLines);
if (listLines.Count > 0 && listRefLines.Count > 0)
{
// remove the columns row from any non-zero index references
listRefLines.RemoveAt(0);
}
listLines.AddRange(listRefLines);
WaitDialog.Instance.ProgressStep(0);
var nPriorCount = listDefineLines.Count;
zRefReader.GetDefineData(zReference, listDefineLines);
if (listDefineLines.Count == nPriorCount)
{
Logger.AddLogLine(
"No defines found for reference: {0}".FormatString(zReference.RelativePath));
}
zRefReader.FinalizeReferenceLoad();
WaitDialog.Instance.ProgressStep(0);
}
}
ProcessLines(listLines, listDefineLines, zRefReader?.ReferencePath);
}
