private static void SearchDirectory(ConsoleUI consoleUI) { while (true) { var benchMark = new DirectoryScannerBenchMark(); var implementationProvider = new BenchmarkBasedImplementationProvider(benchMark); consoleUI.DisplayImplementationMenu(implementationProvider); var index = consoleUI.GetMenuChoice(); if (index == 0) { return; } var typeName = implementationProvider.GetImplementations().Keys.OrderBy(k => k).ToArray()[index - 1]; var implementation = ImplementationFactory.CreateInstance(typeName); var rootFolder = consoleUI.GetInput("Please specify root folder", "c:\\program files"); var searchPattern = consoleUI.GetInput("Please specify searchPattern", "*.exe"); Console.WriteLine($"\r\nImplementation:\t{typeName}"); Console.WriteLine($"Root folder:\t{rootFolder}"); Console.WriteLine($"Search pattern:\t{searchPattern}"); var w = new Stopwatch(); w.Start(); var count = implementation.EnumerateFiles(rootFolder, searchPattern).Count(); //Thread.Sleep(1000); w.Stop(); Console.WriteLine($"\r\nFound {count} file(s). Operation took {w.ElapsedMilliseconds} msecs."); Console.WriteLine(@"Press any key to continue"); Console.ReadKey(); } }
/// <summary> /// Static constructor to setup dynamic implementation /// </summary> static GraceDynamicMethod() { DynamicImplementation = DefaultImplementation.Clone(); DynamicImplementation.ExportSingleton <IDynamicMethodTargetCreator>(f => new DynamicMethodTargetCreator()); DynamicImplementation.ExportSingleton <INewExpressionGenerator>(f => new NewExpressionGenerator()); DynamicImplementation.ExportSingleton <IConstantExpressionCollector>(f => new ConstantExpressionCollector()); DynamicImplementation.ExportSingleton <IConstantExpressionGenerator>(f => new ConstantExpressionGenerator()); DynamicImplementation.ExportSingleton <IMemeberInitExpressionGenerator>(f => new MemeberInitExpressionGenerator()); DynamicImplementation.ExportSingleton <IArrayInitExpressionGenerator>(f => new ArrayInitExpressionGenerator()); DynamicImplementation.ExportSingleton <IParameterExpressionGenerator>(f => new ParameterExpressionGenerator()); DynamicImplementation.ExportSingleton <ICallExpressionGenerator>(f => new CallExpressionGenerator()); DynamicImplementation.ExportSingleton <IAssignExpressionGenerator>(f => new AssignExpressionGenerator()); DynamicImplementation.ExportInstance <ILinqToDynamicMethodConverter>(f => new LinqToDynamicMethodConverter(f)); DynamicImplementation.ExportInstance <IActivationStrategyCompiler>( f => new DynamicMethodStrategyCompiler(f.InjectionScope.ScopeConfiguration, f.Locate <IActivationExpressionBuilder>(), f.Locate <IAttributeDiscoveryService>(), f.Locate <IDefaultStrategyExpressionBuilder>(), f.Locate <IInjectionContextCreator>(), f.Locate <IExpressionConstants>(), f.Locate <IInjectionStrategyDelegateCreator>(), f.Locate <ILinqToDynamicMethodConverter>())); }
private IDeclarationList Declarations() { IDeclarationList declarations = ImplementationFactory.CreateDeclarationList(); PqlToken declarationType; while (currentToken.Type != PqlTokenType.SELECT) { switch (currentToken.Type) { case PqlTokenType.PROCEDURE: case PqlTokenType.STMTLST: case PqlTokenType.STMT: case PqlTokenType.ASSIGN: case PqlTokenType.CALL: case PqlTokenType.WHILE: case PqlTokenType.IF: case PqlTokenType.VARIABLE: case PqlTokenType.CONSTANT: case PqlTokenType.PROG_LINE: declarationType = currentToken; Eat(currentToken.Type); while (currentToken.Type != PqlTokenType.SEMI) { declarations.AddDeclaration(Declaration(declarationType)); } Eat(PqlTokenType.SEMI); break; default: throw new Exception(); } } return(declarations); }
public void EnumerateFiles( [Values( //nameof(FastDirectoryEnumeratorScanner), // causes stackoverflow nameof(FastFileInfoScanner), //nameof(DirectoryEnumerationAsyncScanner), // Had a hardcoded SearchOption.TopDirectoryOnly. but after the fix still has errors nameof(DirectoryTreeWalkerScanner) )] string implementation, [Values( @"c:\program files", @"c:\program files (x86)" )] string path, [Values( @"*.*", @"*.exe", @"*.notexisting" )] string searchPattern ) { // Arrange var sut = ImplementationFactory.CreateInstance(implementation); var referenceImplementation = new BuiltInDirectoryScanner(); // Act var actual = sut.EnumerateFiles(path, searchPattern).ToList(); // Assert var expected = referenceImplementation.EnumerateFiles(path, searchPattern).ToList(); Assert.AreEqual(expected.Count, actual.Count); // TODO: Check filenames, filesizes for equality }
public IActionResult ReadText(TextDto dto) { var service = ImplementationFactory.Create(_services, dto.Implementation); var numberOfWords = service.Read(dto.Text); return(Ok("There are " + numberOfWords + " words in the text")); }
protected override IEntityList LoadSingleRightArg(IProgramKnowledgeBase pkb) { IEntity entity = pkb.Statements.GetEntityByAttribute((RightRef as PqlInteger).Value); IEntityList result = ImplementationFactory.CreateEntityList(); result.AddEntity(entity); return(result); }
public Assign(Variable left, Token operation, Factor right, int programLine) : base(programLine) { Left = left; Operation = operation; Right = right; AffectedBy = ImplementationFactory.CreateStatementList(); Affecting = ImplementationFactory.CreateStatementList(); }
protected override IEntityList LoadSingleLeftArg(IProgramKnowledgeBase pkb) { IEntity entity = pkb.Procedures.GetEntityByAttribute((LeftRef as PqlString).Value); IEntityList result = ImplementationFactory.CreateEntityList(); result.AddEntity(entity); return(result); }
public List <IStatementList> GetPathsFrom(Statement statement) { List <IStatementList> paths = new List <IStatementList>(); IStatementList newPath = ImplementationFactory.CreateStatementList(); BuildPath(paths, newPath, statement); return(paths); }
protected override IEntityList ProcessRightSide(IProgramKnowledgeBase pkb, IEntity arg) { Statement statement = arg as Statement; Statement followed = pkb.FollowsTable.GetFollowedBy(statement); IStatementList result = ImplementationFactory.CreateStatementList(); result.AddStatement(followed); return(result); }
protected override IEntityList ProcessRightSide(IProgramKnowledgeBase pkb, IEntity arg) { Statement statement = arg as Statement; Statement parent = pkb.ParentTable.GetParent(statement); IStatementList result = ImplementationFactory.CreateStatementList(); result.AddStatement(parent); return(result); }
public Variable(Token token) { Name = token.Value.ToString(); Attribute = new Attribute("varName", Name); ModifiedByProcedures = ImplementationFactory.CreateProcedureList(); ModifiedByStatements = ImplementationFactory.CreateStatementList(); UsedByProcedures = ImplementationFactory.CreateProcedureList(); UsedByStatements = ImplementationFactory.CreateStatementList(); }
public Variable(string name) { Name = name; Attribute = new Attribute("varName", Name); ModifiedByProcedures = ImplementationFactory.CreateProcedureList(); ModifiedByStatements = ImplementationFactory.CreateStatementList(); UsedByProcedures = ImplementationFactory.CreateProcedureList(); UsedByStatements = ImplementationFactory.CreateStatementList(); }
public Procedure(string name, IStatementList body) { Name = name; Body = body; Attribute = new Attribute("procName", Name); Modifying = ImplementationFactory.CreateVariableList(); Using = ImplementationFactory.CreateVariableList(); CalledBy = ImplementationFactory.CreateProcedureList(); Calling = ImplementationFactory.CreateProcedureList(); }
public Statement(int programLine) { ProgramLine = programLine; Attribute = new Attribute("progLine", ProgramLine.ToString()); Modifying = ImplementationFactory.CreateVariableList(); Using = ImplementationFactory.CreateVariableList(); NextedBy = ImplementationFactory.CreateStatementList(); Nexting = ImplementationFactory.CreateStatementList(); Children = ImplementationFactory.CreateStatementList(); }
public IStatementList GetUsesStatements(Variable variable) { if (variable != null) { return(variable.UsedByStatements); } else { return(ImplementationFactory.CreateStatementList()); } }
public IProcedureList GetUsesProcedures(Variable variable) { if (variable != null) { return(variable.UsedByProcedures); } else { return(ImplementationFactory.CreateProcedureList()); } }
public IVariableList GetUsedBy(Statement statement) { if (statement != null) { return(statement.Using.Copy()); } else { return(ImplementationFactory.CreateVariableList()); } }
public IStatementList GetNextedBy(Statement statement) { if (statement != null) { return(statement.Nexting.Copy()); } else { return(ImplementationFactory.CreateStatementList()); } }
public IStatementList GetParentedBy(Statement statement) { if (statement != null) { return(statement.Children.Copy()); } else { return(ImplementationFactory.CreateStatementList()); } }
public IVariableList GetUsedBy(Procedure procedure) { if (procedure != null) { return(procedure.Using.Copy()); } else { return(ImplementationFactory.CreateVariableList()); } }
public IStatementList GetAffects(Assign assignment) { if (assignment != null) { return(assignment.AffectedBy.Copy()); } else { return(ImplementationFactory.CreateStatementList()); } }
public IProcedureList GetCalledBy(Procedure procedure) { if (procedure != null) { return(procedure.Calling.Copy()); } else { return(ImplementationFactory.CreateProcedureList()); } }
public IStatementList GetFollowsT(Statement statement) { IStatementList following = ImplementationFactory.CreateStatementList(); Statement followingStatement = GetFollows(statement); following.AddStatement(followingStatement); for (int i = 0; i < following.GetSize(); i++) { following.AddStatement(GetFollows(following[i])); } return(following); }
public IStatementList GetFollowedByT(Statement statement) { IStatementList followed = ImplementationFactory.CreateStatementList(); Statement followedStatement = GetFollowedBy(statement); followed.AddStatement(followedStatement); for (int i = 0; i < followed.GetSize(); i++) { followed.AddStatement(GetFollowedBy(followed[i])); } return(followed); }
public IStatementList GetParentT(Statement statement) { IStatementList parents = ImplementationFactory.CreateStatementList(); Statement parentStatement = GetParent(statement); parents.AddStatement(parentStatement); for (int i = 0; i < parents.GetSize(); i++) { parents.AddEntity(GetParent(parents[i])); } return(parents); }
private IProcedureList Procedures() { Procedure procedure = Procedure(); IProcedureList procedures = ImplementationFactory.CreateProcedureList(); procedures.AddProcedure(procedure); while (currentToken.Type == TokenType.PROCEDURE) { procedures.AddProcedure(Procedure()); } return(procedures); }
private IStatementList Statements() { Statement statement = SingleStatement(); IStatementList statements = ImplementationFactory.CreateStatementList(); statements.AddStatement(statement); while (currentToken.Type != TokenType.RBRACE) { statements.AddStatement(SingleStatement()); } return(statements); }
/// <summary> /// default constructor /// </summary> public InjectionScopeConfiguration(ImplementationFactory implementationFactory = null) { Implementation = implementationFactory ?? DefaultImplementation.Clone(); Behaviors = new ExportCompilationBehavior(); CacheArraySize = 64; ExportStrategyArraySize = 16; AutoRegisterUnknown = true; ExportAsBase = false; TrackDisposableTransients = true; SupportFuncType = true; ExportByInterfaceFilter = DefaultInterfaceFilter; }
public DesignExtractor() { Statements = ImplementationFactory.CreateStatementList(); Variables = ImplementationFactory.CreateVariableList(); Procedures = ImplementationFactory.CreateProcedureList(); Constants = ImplementationFactory.CreateConstantList(); FollowsTable = ImplementationFactory.CreateFollowsTable(); ModifiesTable = ImplementationFactory.CreateModifiesTable(); ParentTable = ImplementationFactory.CreateParentTable(); UsesTable = ImplementationFactory.CreateUsesTable(); CallsTable = ImplementationFactory.CreateCallsTable(); NextTable = ImplementationFactory.CreateNextTable(); AffectsTable = ImplementationFactory.CreateAffectsTable(); calls = new Dictionary <Procedure, List <Call> >(); }