public void SetUp()
{
fakeReader = A.Fake<ISourceReader>();
fakeClouder = A.Fake<ICloudMaker>();
var temp = string.Empty;
A.CallTo(() => fakeReader.ReadWords(temp, new IFilter[0])).Returns(new List<string>() {"a", "b"});
}
static void Main(string[] args)
{
// Create a factory and create a web reader, system reader and scribe object.
Factory fact = new Factory();
fact.RegisterType(new WebReader("SomeWebLocation"));
fact.RegisterType(new SystemReader("SomeSystemLocation"));
fact.RegisterType(new ConsoleScribe());
// Now create the wrapped versions of different readers. IOC will inject the appropriate
// class already there based on interface/generic requirements.
ISourceReader webReader = (ISourceReader)fact.CreateInstance(typeof(WrappedWebReader <,>));
ISourceReader systemReader = (ISourceReader)fact.CreateInstance(typeof(WrappedSystemReader <,>));
Console.WriteLine("Calling both generated interfaces....");
webReader.ReadContent();
systemReader.ReadContent();
// Now, lets say you did some work and passed the factory around instead of the actual objects.
// You can access them in two ways.
// 1. Just call create instance again, you will get the type you created earlier
// 2. Calling GetInstance, then taking the item from the returned list and using it
Console.WriteLine("Retrieve both interfaces from the factory again....");
ISourceReader system = (ISourceReader)fact.CreateInstance(typeof(WrappedSystemReader <,>));
system.ReadContent();
List <object> wrappedSysReaders = fact.GetInstance(typeof(WrappedWebReader <,>));
if (wrappedSysReaders.Count > 0)
{
(wrappedSysReaders[0] as ISourceReader).ReadContent();
}
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
object res = null;
var word = reader.LastKeyword;
foreach (var id in scope.KnownIdentifiers)
{
if (!id.StartsWith("cr:"))
{
continue;
}
var cr = scope[id] as IConstantReader;
if (cr.TryRead(word, out res))
{
break;
}
res = null;
}
if (res == null)
{
throw new SyntaxException(reader, string.Format("Unrecognized word : {0}", word));
}
reader.ReadNext();
yield return(res);
}
public PgmReceiver(string address, int port, ISourceReader reader)
{
_socket = new PgmSocket();
_ip = address;
_port = port;
_reader = reader;
}
private static void CreateBuyerSummeryLists(ISourceReader reader, string base_out_put_folder)
{
var buyers = reader.GetBuyers();
var reservations = reader.GetReservations();
var output_folder = base_out_put_folder + "\\BuyerSummeryLists";
if (!Directory.Exists(output_folder))
{
Directory.CreateDirectory(output_folder);
}
foreach (var buyer in buyers)
{
var new_file_path = output_folder + "\\" + buyer.Id + "-" + buyer.Name + ".xlsx";
File.Copy("Templates\\ReceiverSummeryTemplate01.xlsx", new_file_path, true);
var workbook = new XLWorkbook(new_file_path);
var work_sheet = workbook.Worksheets.First();
BuyerSummeryFileCreator.Create(work_sheet, buyer,
reservations.Where(x => x.Buyer.Id == buyer.Id));
workbook.Save();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="parent">The source reader to buffer. The current keyword will be the first of the loop.</param>
public LoopedSourceReader(ISourceReader parent)
{
m_Parent = parent;
m_Read = new List <Snapshot>();
m_Current = 0;
AddSnapshot();
}
private static Type ReadType(ISourceReader reader, IExecutionScope scope)
{
reader.ReadNext();
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
if (!scope.Contains(reader.LastKeyword) || !scope.IsOfType <Type>(reader.LastKeyword))
{
throw new SyntaxException(reader, string.Format("Unknown type {0}", reader.LastKeyword));
}
var t = scope[reader.LastKeyword] as Type;
if (t == null)
{
throw new SyntaxException(reader, "Type resolving failed.");
}
if (scope.IsGeneric(reader.LastKeyword))
{
reader.ReadNext();
if (!reader.LastKeyword.Equals(DefaultLanguageKeywords.GenericTypeArgumentKeyword))
{
throw new SyntaxException(reader,
"In a Generic declaration, the Generic argument keyword should follow the Type name.");
}
Type innerType = ReadType(reader, scope);
t = t.GetGenericTypeDefinition().MakeGenericType(innerType);
}
return(t);
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
if (!reader.LastKeyword.Equals(DefaultLanguageKeywords.InputKeyword))
{
throw new SyntaxException(reader, "Input sections should start with the input keyword");
}
reader.ReadNext();
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
IDictionary <string, Type> parametersMap = new Dictionary <string, Type>();
var exec = DefaultLanguageNodes.InputStatement.Execute(reader, scope, skipExec);
var pmap = exec.ExecuteNext() as IDictionary <string, Type>;
foreach (var kvp in pmap)
{
parametersMap.Add(kvp);
}
yield return(parametersMap);
}
private SourceList <T> GetList <T>(DbCommand cmd, DbTrans dbTran)
where T : Entity
{
try
{
using (ISourceReader reader = dbProvider.ExecuteReader(cmd, dbTran))
{
SourceList <T> list = new SourceList <T>();
FastCreateInstanceHandler creator = DataUtils.GetFastInstanceCreator(typeof(T));
while (reader.Read())
{
T entity = (T)creator();
entity.SetAllValues(reader);
entity.Attach();
list.Add(entity);
}
reader.Close();
return(list);
}
}
catch
{
throw;
}
}
public SourceReaderService(ISourceReader sourceReader,
IHouseRepository houseRepository
)
{
_sourceReader = sourceReader;
_houseRepository = houseRepository;
}
/// <summary>
/// <see cref="ISyntaxTreeItem.Execute(ISourceReader, IExecutionScope, bool)" />
/// </summary>
public IScriptExecution Execute(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader == null)
{
return(null);
}
var word = reader.LastKeyword;
if (DefaultLanguageNodes.Assignation.IsStartOfNode(word, scope))
{
return(DefaultLanguageNodes.Assignation.Execute(reader, scope, skipExec));
}
if (DefaultLanguageNodes.Call.IsStartOfNode(word, scope))
{
return(DefaultLanguageNodes.Call.Execute(reader, scope, skipExec));
}
if (DefaultLanguageNodes.Variable.IsStartOfNode(word, scope))
{
return(DefaultLanguageNodes.Variable.Execute(reader, scope, skipExec));
}
if (DefaultLanguageNodes.Constant.IsStartOfNode(word, scope))
{
return(DefaultLanguageNodes.Constant.Execute(reader, scope, skipExec));
}
throw new SyntaxException(reader, "Not recognized as operation");
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
if (!IsStartOfNode(reader.LastKeyword, scope))
{
throw new SyntaxException(reader, "Lists should start with the list begin symbol.");
}
reader.ReadNext();
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
while (!reader.LastKeyword.Equals(DefaultLanguageKeywords.ListEndSymbol))
{
if (skipExec)
{
reader.ReadNext();
continue;
}
var exec = DefaultLanguageNodes.Statement.Execute(reader, scope, skipExec);
foreach (var o in exec)
{
yield return(o);
}
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
}
reader.ReadNext();
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
var word = reader.LastKeyword;
if (!IsStartOfNode(word, scope))
{
throw new SyntaxException(reader, "Variable name does not start with $");
}
var identifier = word;
yield return(identifier);
object value = null;
if (!skipExec)
{
try
{
value = scope[identifier];
}
catch (ScopeException se)
{
throw new ScopeException(reader, se.Description);
}
}
reader.ReadNext();
yield return(value);
}
public static Action<long, long> Concat(ISourceReader reader, ProcessSample transforms, Func<bool> isAborted)
{
return (offsetA, offsetV) =>
{
reader.SetCurrentPosition(0);
var stream = FromSource(reader, isAborted);
bool firstV = false;
stream(s =>
{
if (isAborted())
return false;
if (s.Flags.EndOfStream)
return transforms(s);
if (!firstV && s.Stream.CurrentMediaType.IsVideo)
{
firstV = true;
return true;
}
if (s.Stream.CurrentMediaType.IsVideo)
s.Resequence(offsetV);
if (s.Stream.CurrentMediaType.IsAudio)
s.Resequence(offsetA);
return transforms(s);
});
};
}
public PgmReceiver(string address, int port, ISourceReader reader)
{
_socket = new PgmSocket();
_ip = address;
_port = port;
_reader = reader;
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
var varexec = DefaultLanguageNodes.Variable.Execute(reader, scope, true);
var identifier = varexec.ExecuteNext() as string;
reader.ReadNext();
if (!reader.LastKeyword.Equals(DefaultLanguageKeywords.EachKeyword))
{
throw new SyntaxException(reader,
"In loop each declaration, the variable name should be folowed by the each keyword");
}
reader.ReadNext();
var sourceexec = DefaultLanguageNodes.Operation.Execute(reader, scope, skipExec);
object lastValue = null;
foreach (var o in sourceexec)
{
lastValue = o;
yield return(o);
}
if (lastValue is ICollection == false)
{
throw new OperationException(reader, "Each loop source is not a collection");
}
var source = (lastValue as ICollection).GetEnumerator();
LoopCondition cond = () => Condition(identifier, source, scope);
yield return(cond);
}
private Program(ICloudMaker maker, IFilter[] filters, ISourceReader reader, IVisulisation ui, IWriter writer)
{
Maker = maker;
Filters = filters;
Reader = reader;
UI = ui;
Writer = writer;
}
public CompressionPipeline(
ISourceReader reader, IWorker worker, IResultWriter writer, ILogger logger)
{
_reader = reader ?? throw new ArgumentNullException(nameof(reader));
_worker = worker ?? throw new ArgumentNullException(nameof(worker));
_writer = writer ?? throw new ArgumentNullException(nameof(writer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public Snapshot(ISourceReader toSnap)
{
LastKeyword = toSnap.LastKeyword;
Column = toSnap.Column;
Line = toSnap.Line;
LineOfCode = toSnap.LineOfCode;
ReadingComplete = toSnap.ReadingComplete;
}
/// <summary>
/// Constructor for Script.
/// </summary>
/// <param name="reader"></param>
/// <param name="defaultScope"></param>
public Script(ISourceReader reader, IExecutionScope defaultScope)
{
m_Reader = new LoopedSourceReader(reader);
m_Scope = defaultScope;
var exec = DefaultLanguageNodes.ScriptRoot.Execute(m_Reader, m_Scope.MakeSubScope(), false);
ExpectedArguments = exec.ExecuteNext() as IDictionary <string, Type>;
m_Reader.Reset();
}
void TestReader(ISourceReader reader, string[] expected)
{
foreach (string str in expected)
{
Assert.IsFalse(reader.ReadingComplete);
Assert.IsNotNull(reader.LastKeyword);
Assert.AreEqual(str, reader.LastKeyword);
reader.ReadNext();
}
}
public Lexer(ISourceReader reader)
{
Expect.NotNull(reader);
_reader = reader;
_line = 1;
_col = 1;
_startLine = 1;
_startCol = 1;
_read = String.Empty;
}
public GZipManager(string inFile, ISourceReader reader, IChunkWriter chunkWriter,
IFileSplitterFactory fileSplitterFactory, ICompressorFactory compressorFactory, ITaskFactory taskFactory, IErrorLogs errorLogs)
{
_chunkWriter = chunkWriter;
_sourceReader = reader;
_taskFactory = taskFactory;
_inFile = inFile;
_fileSplitterFactory = fileSplitterFactory;
_compressorFactory = compressorFactory;
_errorLogs = errorLogs;
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (!IsStartOfNode(reader.LastKeyword, scope))
{
throw new SyntaxException(reader, "While declaration should start with while keyword.");
}
reader.ReadNext();
var conditionReader = new LoopedSourceReader(reader);
LoopCondition cond = () => Condition(conditionReader, scope, skipExec);
yield return(cond);
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (!IsStartOfNode(reader.LastKeyword, scope))
{
throw new SyntaxException(reader, "If section should start with if keyword");
}
reader.ReadNext();
var ifScope = scope.MakeSubScope();
var condexec = DefaultLanguageNodes.Operation.Execute(reader, ifScope, skipExec);
object lastResult = null;
foreach (var o in condexec)
{
lastResult = o;
if (!skipExec)
{
yield return(o);
}
}
if (lastResult is bool == false)
{
throw new OperationException(reader, "if condition is not boolean value");
}
var cond = (bool)lastResult;
var thenexec = DefaultLanguageNodes.Statement.Execute(reader, ifScope, !cond);
foreach (var o in thenexec)
{
if (cond)
{
yield return(o);
}
}
if (reader.ReadingComplete)
{
yield break;
}
if (!reader.LastKeyword.Equals(DefaultLanguageKeywords.ElseKeyword))
{
yield break;
}
reader.ReadNext();
var elseexec = DefaultLanguageNodes.Statement.Execute(reader, ifScope, cond);
foreach (var o in elseexec)
{
if (!cond)
{
yield return(o);
}
}
}
public SourceReaderSample(ISourceReader reader, SourceStream stream, SourceReaderSampleFlags flags, long timestamp, long duration, Sample sample, int count)
{
Reader = reader;
Stream = stream;
Flags = flags;
Timestamp = timestamp;
Duration = duration;
Count = count;
Sample = sample;
SegmentDuration = duration;
SegmentTimeStamp = timestamp;
}
public ParallelCompressionOrchestrationService(
IClientOptionsService clientOptionsService,
IParallelCompressionService parallelCompressionService,
ISourceReader sourceReader,
IDestinationWriter destinationWriter,
IOutcomeService outcomeService,
IThreadService threadService)
{
_clientOptionsService = clientOptionsService;
_parallelCompressionService = parallelCompressionService;
_sourceReader = sourceReader;
_destinationWriter = destinationWriter;
_outcomeService = outcomeService;
_threadService = threadService;
}
public static void CreateAllExcelFiles(ISourceReader reader, string base_out_put_folder)
{
if (!Directory.Exists(base_out_put_folder))
{
Directory.CreateDirectory(base_out_put_folder);
}
Console.WriteLine("Creating list of Buyers...");
CreateBuyersList(reader, base_out_put_folder);
Console.WriteLine("Creating Picklists...");
CreatePicklists(reader, base_out_put_folder);
Console.WriteLine("Creating lists of buyers reservations...");
CreateBuyerSummeryLists(reader, base_out_put_folder);
Console.WriteLine("Creating a Master list...");
CreateMasterlist(reader, base_out_put_folder);
}
public static IList <string> MakeFileForLugbulkDatabase(ISourceReader reader)
{
var lines = new List <string>();
// Elements
// [tblElements]: [ElementId], [BlId], [Description], [BLColor], [TlgColor], [TlgColorId]
// ,[Price], [SumQuantity], [Remainder]
lines.Add("-- Elements --");
var elements = reader.GetElements();
foreach (var element in elements)
{
lines.Add(string.Format("INSERT INTO tblElements (ElementId, BlId, Description, BLColor) VALUES ({0}, '{1}', '{2}', '{3}')",
element.ElementID, element.BricklinkId, element.BricklinkDescription, element.BricklinkColor));
}
lines.Add("");
// Buyers
// [tblBuyers]: [Username], [MoneySum], [BrickAmount]
lines.Add("-- Buyers --");
var buyers = reader.GetBuyers();
foreach (var buyer in buyers)
{
// [tblBuyers]: [Username], [MoneySum], [BrickAmount]
lines.Add(string.Format("INSERT INTO tblBuyers (Username) VALUES ('{0}')", buyer.Name));
}
lines.Add("");
// Amounts
// [tblBuyersAmounts]: [Username], [ElementId], [Amount], [Difference]
lines.Add("-- Amounts --");
var amounts = reader.GetReservations();
foreach (var amount in amounts)
{
// [tblBuyers]: [Username], [MoneySum], [BrickAmount]
lines.Add(string.Format("INSERT INTO tblBuyersAmounts (Username, ElementId, Amount) VALUES ('{0}', {1}, {2})",
amount.Buyer.Name, amount.Element.ElementID, amount.Amount));
}
lines.Add("");
//File.WriteAllLines("lugbulk_data.sql", lines);
return(lines);
}
/// <summary>
/// Validate the provided <paramref name="reader" />.
/// </summary>
/// <param name="reader">The data source to validate</param>
/// <returns>An enumerable of <see cref="ColumnValidationError" /> </returns>
public IEnumerable <ColumnValidationError> ValidateCols(ISourceReader reader)
{
foreach (string line in reader.ReadLines(_rowSeperator))
{
Header = _rowValidator.GetHeader(line);
if (!_colValidator.IsValid(line))
{
ColumnValidationError error = _colValidator.GetError();
_colValidator.ClearErrors();
yield return(error);
}
break; // only process the first line
}
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
var word = reader.LastKeyword;
var method = scope[word] as MethodInfo;
if (method == null)
{
throw new SyntaxException(reader, string.Format("{0} is not a call", word));
}
reader.ReadNext();
var parameters = method.GetParameters();
var args = new object[parameters.Length];
var i = 0;
foreach (var param in parameters)
{
if (reader.ReadingComplete)
{
throw new SyntaxException(reader, "Unexpected end of file");
}
var exec = DefaultLanguageNodes.Operation.Execute(reader, scope, skipExec);
object lastValue = null;
foreach (var o in exec)
{
lastValue = o;
if (!skipExec)
{
yield return(o);
}
}
if (!skipExec && !param.ParameterType.IsAssignableFrom(lastValue.GetType()))
{
throw new OperationException(reader,
string.Format("Wrong parameter for argument {0} of call {1}", param.Name, method.Name));
}
args[i++] = lastValue;
}
if (!skipExec)
{
yield return(method.Invoke(null, args));
}
}
private IEnumerator <object> Exec(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
IDictionary <string, Type> pmap = new Dictionary <string, Type>();
if (DefaultLanguageNodes.InputSection.IsStartOfNode(reader.LastKeyword, scope))
{
var inputexec = DefaultLanguageNodes.InputSection.Execute(reader, scope, skipExec);
object lastValue = null;
foreach (var o in inputexec)
{
lastValue = o;
}
if (lastValue is IDictionary <string, Type> == false)
{
throw new OperationException(reader, "Input section does not yield parameters map.");
}
pmap = lastValue as IDictionary <string, Type>;
}
yield return(pmap);
foreach (var kvp in pmap)
{
if (!scope.Contains(kvp.Key))
{
throw new OperationException(reader,
string.Format("Execution scope does not contain input parameter {0}", kvp.Key));
}
if (!kvp.Value.IsAssignableFrom(scope[kvp.Key].GetType()))
{
throw new OperationException(reader,
string.Format("Provided input parameter {0} wrong type. Expected {1}got {2}", kvp.Key,
kvp.Value, scope[kvp.Key].GetType()));
}
}
var scriptScope = scope.MakeSubScope();
while (!reader.ReadingComplete)
{
var exec = DefaultLanguageNodes.Statement.Execute(reader, scriptScope, skipExec);
foreach (var o in exec)
{
yield return(o);
}
}
}
/// <summary>
/// <see cref="ISyntaxTreeItem.Execute(ISourceReader, IExecutionScope,bool)" />
/// </summary>
public IScriptExecution Execute(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader == null)
{
return(null);
}
if (DefaultLanguageNodes.Declaration.IsStartOfNode(reader.LastKeyword, scope))
{
return(DefaultLanguageNodes.Declaration.Execute(reader, scope, skipExec));
}
if (DefaultLanguageNodes.ListOfDeclarations.IsStartOfNode(reader.LastKeyword, scope))
{
return(DefaultLanguageNodes.ListOfDeclarations.Execute(reader, scope, skipExec));
}
throw new SyntaxException(reader, "Not recognized as input statement");
}
/// <summary>
/// <see cref="ISyntaxTreeItem.Execute(ISourceReader, IExecutionScope, bool)" />
/// </summary>
public IScriptExecution Execute(ISourceReader reader, IExecutionScope scope, bool skipExec)
{
if (reader == null)
{
return(null);
}
if (DefaultLanguageNodes.If.IsStartOfNode(reader.LastKeyword, scope))
{
return(DefaultLanguageNodes.If.Execute(reader, scope, skipExec));
}
if (DefaultLanguageNodes.Loop.IsStartOfNode(reader.LastKeyword, scope))
{
return(DefaultLanguageNodes.Loop.Execute(reader, scope, skipExec));
}
throw new SyntaxException(reader, "Not recognized as section");
}
public IEnumerable <RowValidationError> Validate(ISourceReader reader)
{
foreach (string line in reader.ReadLines(_rowSeperator))
{
_totalRowsChecked++;
if (IsHeaderRow())
{
}
else if (!_rowValidator.IsValid(line))
{
RowValidationError error = _rowValidator.GetError();
error.Row = _totalRowsChecked;
_rowValidator.ClearErrors();
yield return(error);
}
}
}
public static Action<long, long> Concat(ISourceReader reader, ProcessSample transforms, Action<long, long> next, Func<bool> isAborted)
{
return (offsetA, offsetV) =>
{
var newOffsetA = offsetA;
var newOffsetV = offsetV;
reader.SetCurrentPosition(0);
var stream = FromSource(reader, isAborted);
stream(s =>
{
if (isAborted())
return false;
if (s.Flags.EndOfStream)
return false;
if (s.Stream.CurrentMediaType.IsVideo)
s.Resequence(offsetV);
if (s.Stream.CurrentMediaType.IsAudio)
s.Resequence(offsetA);
var r = transforms(s);
if (s.Stream.CurrentMediaType.IsVideo)
newOffsetV = s.SampleTime;
if (s.Stream.CurrentMediaType.IsAudio)
newOffsetA = s.SampleTime;
return r;
});
next(newOffsetA, newOffsetV);
};
}
internal void Resequence(long offset, long duration, ISourceReader reader)
{
this.Reader = reader;
Duration = SegmentDuration = duration;
Timestamp += offset;
SampleTime += offset;
SegmentTimeStamp += offset;
}
public TokenScanner(ISourceReader reader)
{
this.reader = reader;
}
public StockQuotesStream(ISourceReader<StockQuote> stockQuotesReader)
{
_stockQuotesReader = stockQuotesReader;
}
public static void StartConcat(ISourceReader reader, ProcessSample transforms, Action<long, long> next, Func<bool> isAborted)
{
Concat(reader, transforms, next, isAborted)(0, 0);
}
public static Action<ProcessSample> FromSource(ISourceReader shortSourceReader, Func<bool> isAborted)
{
return next =>
{
foreach (var s in shortSourceReader.Samples())
if (isAborted())
break;
else
next(s);
};
}
public FilesController()
{
_excelReader = new ExcelReader();
}
