public FakeConfigurationManager(IConfigurationFactory configurationFactory, IExpressionParser parser, ExpressionCallRule.Factory callRuleFactory, IProxyGenerator proxyGenerator) { this.configurationFactory = configurationFactory; this.expressionParser = parser; this.ruleFactory = callRuleFactory; this.proxyGenerator = proxyGenerator; }
public ResourceKeyStack BranchFor(IExpressionParser expression) { var branch = (ResourceKeyStack)MemberwiseClone(); branch._expression = expression; return(branch); }
internal void Parse(ExpressionParserHelper parseHelper) { IgnoreSpaces(parseHelper); if (!parseHelper.HasMore()) { return; } parseHelper.Next(); Token current = parseHelper.Current; IExpressionParser parser = null; if (current.Type == TokenType.Seperator) { parser = PARSERS_BY_STR[current.Contents]; } else { parser = PARSERS_BY_TYPE[typeof(PropertyOrConstant)]; } parser.Parse(parseHelper); if (parseHelper.HasMore()) { Parse(parseHelper); } }
public StreamMessageHandlerMethodFactory( ISmartMessageConverter compositeMessageConverter, IConversionService conversionService, IExpressionParser expressionParser, IEvaluationContext evaluationContext) { MessageConverter = compositeMessageConverter; var resolvers = new List <IHandlerMethodArgumentResolver>(); resolvers.Add(new SmartPayloadArgumentResolver(compositeMessageConverter)); resolvers.Add(new SmartMessageMethodArgumentResolver(compositeMessageConverter)); resolvers.Add(new HeaderMethodArgumentResolver(conversionService)); resolvers.Add(new HeadersMethodArgumentResolver()); resolvers.Add(new NullAwarePayloadArgumentResolver(compositeMessageConverter)); resolvers.Add(new PayloadExpressionArgumentResolver(expressionParser, evaluationContext)); resolvers.Add(new PayloadsArgumentResolver(expressionParser, evaluationContext)); resolvers.Add(new DictionaryArgumentResolver(expressionParser, evaluationContext)); SetArgumentResolvers(resolvers); AfterPropertiesSet(); }
public BinopExpresison Parse(ILexer lexer, IExpressionParser expressionParser, IWasmicSyntaxTreeExpression lhs) { Operation operation; switch (lexer.Next.TokenType) { case TokenType.Plus: operation = Operation.Add; break; case TokenType.Minus: operation = Operation.Subtract; break; case TokenType.Star: operation = Operation.Multiply; break; case TokenType.Slash: operation = Operation.Divide; break; default: throw new WasmicCompilerException($"{lexer.Next.TokenType} is not binop"); } lexer.Advance(); // eat operand var rhs = expressionParser.GetExpression(); return(new BinopExpresison(lhs, rhs, operation)); }
public ScientificCalculator( IInputBuffer buffer, IOperatorLookup lookup, IUnitConverter unitConverter, IOperatorConverter operatorConverter, IExpressionBuilder builder, IExpressionParser parser, IEvaluate evaluator, IMemoryStorage memory ) : base( buffer, lookup, unitConverter, operatorConverter, builder, parser, evaluator, memory ) { }
public TwisterParser( Func <IEnumerable <IToken>, ITokenMatcher> createTokenMatcher, IExpressionParser expressionParser) { _createTokenMatcher = createTokenMatcher; _expressionParser = expressionParser; }
public FunctionEvaluator(IExpressionParser evaluator, string name, IOption <char> optionalFirst, IJTokenEvaluator[] parameters) { this.name = name; this.optionalFirst = optionalFirst; this.parameters = parameters; this.evaluator = evaluator; }
public GroupRule( RouterGroupConfiguration configuration, IExpressionParser expressionParser) { if (configuration.Disabled) { return; } ConditionLogic = configuration.ConditionLogic; var rules = new List <Rule>(); if (configuration.Conditions != null) { rules.AddRange(configuration.Conditions .Where(c => !c.Disabled) .Select(c => CreateConditionRule(c, expressionParser))); } if (configuration.Groups != null) { rules.AddRange( configuration.Groups .Where(g => !g.Disabled) .Select(g => new GroupRule(g, expressionParser))); } Rules = rules.ToArray(); }
public MemberMatchService( Func <IScoped <ISearchService> > searchServiceFactory, IResourceDeserializer resourceDeserializer, ISearchIndexer searchIndexer, ISearchParameterDefinitionManager.SearchableSearchParameterDefinitionManagerResolver searchParameterDefinitionManagerResolver, IExpressionParser expressionParser, ILogger <MemberMatchService> logger) { EnsureArg.IsNotNull(searchServiceFactory, nameof(searchServiceFactory)); EnsureArg.IsNotNull(resourceDeserializer, nameof(resourceDeserializer)); EnsureArg.IsNotNull(searchIndexer, nameof(searchIndexer)); EnsureArg.IsNotNull(searchParameterDefinitionManagerResolver, nameof(searchParameterDefinitionManagerResolver)); EnsureArg.IsNotNull(expressionParser, nameof(expressionParser)); EnsureArg.IsNotNull(logger, nameof(logger)); _searchServiceFactory = searchServiceFactory; _resourceDeserializer = resourceDeserializer; _searchIndexer = searchIndexer; _expressionParser = expressionParser; var searchParameterDefinition = searchParameterDefinitionManagerResolver(); _coverageBeneficiaryParameter = searchParameterDefinition.GetSearchParameter("Coverage", "beneficiary"); _resourceTypeSearchParameter = searchParameterDefinition.GetSearchParameter(ResourceType.Resource.ToString(), SearchParameterNames.ResourceType); _logger = logger; }
public Parser(Lexer lexer, IExpressionParser expressionParser) { _lexer = lexer; _expressionParser = expressionParser; _expressionParser.ParserError += (s, a) => AddError(a); }
public override Expression GetExpression(IExpressionParser factory) { // add constraints for activity type return(Expression.AndExpression( factory.Parse($"{TurnPath.ACTIVITY}.type == '{this.Type}'"), base.GetExpression(factory))); }
public Comparison Parse(ILexer lexer, IExpressionParser expressionParser, IWasmicSyntaxTreeExpression lhs) { ComparisonOperator op; switch (lexer.Next.TokenType) { case TokenType.EqualComparer: op = ComparisonOperator.Equals; break; case TokenType.GrThanComparer: op = ComparisonOperator.GreaterThan; break; case TokenType.GrThanOrEqComparer: op = ComparisonOperator.GreaterThanOrEqual; break; case TokenType.LsThanComparer: op = ComparisonOperator.LessThan; break; case TokenType.LsThanOrEqComparer: op = ComparisonOperator.LessThanOrEqual; break; default: throw new WasmicCompilerException( $"expected comparison operator, found {lexer.Next.TokenType}" ); } lexer.Advance(); // eat comparison var rhs = expressionParser.GetExpression(); return(new Comparison(lhs, rhs, op)); }
public string Render(IExpressionParser parser, ITemplateContext context) { StringBuilder output = new StringBuilder(); this.Render(parser, context, output); return(output.ToString()); }
public void Render(IExpressionParser parser, ITemplateContext context, StringBuilder output) { foreach (TokenNode node in this.ChildNodes) { node.Evaluate(parser, context, output); } }
public override Expression GetExpression(IExpressionParser factory) { // add constraints for the intents property if (string.IsNullOrEmpty(this.Intent)) { throw new ArgumentNullException(nameof(this.Intent)); } var intentExpression = factory.Parse($"{TurnPath.RECOGNIZED}.intent == '{this.Intent.TrimStart('#')}'"); // build expression to be INTENT AND (@ENTITY1 != null AND @ENTITY2 != null) if (this.Entities.Any()) { intentExpression = Expression.AndExpression( intentExpression, Expression.AndExpression(this.Entities.Select(entity => { if (entity.StartsWith("@") || entity.StartsWith(TurnPath.RECOGNIZED, StringComparison.InvariantCultureIgnoreCase)) { return(factory.Parse($"exists({entity})")); } return(factory.Parse($"exists(@{entity})")); }).ToArray())); } return(Expression.AndExpression(intentExpression, base.GetExpression(factory))); }
public SyntaxProcessor(IExpressionParser expressionParser, ISyntaxTokenParser tokenParser, ISyntaxAnalyzer syntaxAnalyzer) { _expressionParser = expressionParser; _tokenParser = tokenParser; _syntaxAnalyzer = syntaxAnalyzer; }
public ExpressionDocumentation(ResourceKeyStack messagePath, IExpressionParser expr, Type type) { GatherTokens(expr); _name = type.Name; _messagePath = messagePath.BranchFor(expr); _category = CategoryHelper.GetCategory(type); _description = _messagePath.Description; }
public Monomial(decimal?coefficient, string variable, int?exponent, IExpressionParser parser) { this.parser = parser; this.coefficient = coefficient ?? 1; this.variable = variable?.Trim(); this.exponent = exponent; this.expression = parser.CombineStringExpression(this.coefficient, this.variable, this.exponent); }
public Monomial(Monomial from) { this.parser = from.parser; this.coefficient = from.coefficient; this.variable = from.variable; this.exponent = from.exponent; this.expression = parser.CombineStringExpression(this.coefficient, this.variable, this.exponent); }
public EFExpressionParser(IExpressionParser expParser, IEnumerablePrinter printer) { expParser.CheckNull(nameof(expParser)); printer.CheckNull(nameof(printer)); _expParser = expParser; _printer = printer; }
private void ParseTestPropertyExpression <TValue>(Expression <Func <TestEntity, TValue> > propertyExpression, PropertyInfo expectedProperty) { IExpressionParser testObject = TestServiceProvider.GetRequiredService <IExpressionParser>(); PropertyInfo actual = testObject.ParsePropertyExpression(propertyExpression); Assert.AreEqual(expectedProperty, actual); }
public FakeConfigurationManager(IConfigurationFactory configurationFactory, IExpressionParser parser, ExpressionCallRule.Factory callRuleFactory, ICallExpressionParser callExpressionParser, IInterceptionAsserter interceptionAsserter) { this.configurationFactory = configurationFactory; this.expressionParser = parser; this.ruleFactory = callRuleFactory; this.callExpressionParser = callExpressionParser; this.interceptionAsserter = interceptionAsserter; }
/// <summary> /// Parses <paramref name="expression"/> into new <see cref="Expressions.Expression"/> object and inserts it into internal data structure. /// </summary> /// <param name="expression">Expression in string format</param> /// <param name="negative">Whether expression result should be negative</param> /// <param name="instanceCreator">Parser instance creator for parsing sub-expressions</param> /// <returns></returns> public ExpressionBuilder Expression(string expression, bool negative, ConstructNewParser instanceCreator) { IExpressionParser parser = instanceCreator.Invoke(); Expression expr = parser.Parse(expression, instanceCreator); expr.Negative = negative; components.AddLast(expr); return(this); }
/// <summary> /// Parses a lambda expressions that takes an argument of the specified type and returns the stated return value. /// The expression is a default C# lambda expression of the form "x => x.IsDeleted == true" /// Other examples: /// x => x.ChildEntity.Name /// x => x.Name == "John" /// </summary> /// <typeparam name="TParameter">The type of the parameter.</typeparam> /// <typeparam name="TReturn">The type of the return value.</typeparam> /// <param name="parser">The parser.</param> /// <param name="expression">The expression to parse.</param> /// <param name="otherRequiredTypes">The other required types.</param> /// <returns></returns> public static async Task <Expression <Func <TParameter, TReturn> > > ParseLambdaAsync <TParameter, TReturn>( this IExpressionParser parser, string expression, params Type[] otherRequiredTypes) { var parsedExpression = await parser.ParseLambdaAsync(typeof(TParameter), typeof(TReturn), expression, otherRequiredTypes); return((Expression <Func <TParameter, TReturn> >)parsedExpression); }
public ForExpressionDrawer(string variable, int startValue, int endValue, int stepValue, string body) { this.variable = variable; this.startValue = startValue; this.endValue = endValue; this.stepValue = stepValue; this.body = body; this.expressionParser = new ExpressionParser(); }
//public CalcConverter(IExpressionParser parser) : this(parser, null) { } //public CalcConverter(Dictionary<string, Type> enumParameters) : this(null, enumParameters) { } public CalcConverter(IExpressionParser parser, Dictionary <string, Type> enums) { _parser = parser; if (parser != null && enums != null && enums.Any()) { parser.SetReference(enums.Select(ep => new ReferenceType(ep.Key, ep.Value))); } }
public static void ReplaceExpressionParser(IExpressionParser expressionParser) { if (expressionParser == null) { throw new ArgumentNullException(nameof(expressionParser)); } _parser = new Lazy <IExpressionParser>(() => expressionParser); }
public ProcessorStorageFilesWork(IMathBuffer maths, ICalcIO calcIO, IOperationsHistory operationsHistory, IExpressionParser mathExpressionParser, IPathReader filePathReader, ICalcInputParser inputParser) { Maths = maths; CalcIO = calcIO; OperationsHistory = operationsHistory; MathExpressionParser = mathExpressionParser; FilePathReader = filePathReader; InputParser = inputParser; }
/// <summary> /// Initializes a new instance of the <see cref="Analyzer"/> class. /// </summary> /// <param name="templates">Template list.</param> /// <param name="expressionParser">Expression parser.</param> public Analyzer(List<Template> templates, ExpressionParser expressionParser) { Templates = templates; templateMap = templates.ToDictionary(t => t.Name); // create an evaluator to leverage it's customized function look up for checking var evaluator = new Evaluator(Templates, expressionParser); this._expressionParser = evaluator.ExpressionParser; }
public DebuggerSession(DebuggerConfiguration config, DebuggerOptions options, string name, IExpressionParser parser) : this(config, name) { this.Options = options; this.parser = parser; if (config.IsCLI) AddEvent (new MainMethodBreakpoint (this)); }
private static void CheckPerformance(IExpressionParser expressionParser, string expression) { var stopwatch = Stopwatch.StartNew(); Enumerable .Range(1, 100) .ToList() .ForEach(i => expressionParser.Parse<TestEntity>(expression)); stopwatch.Stop(); Debug.WriteLine("{0}: {1}", expressionParser.GetType().Name, stopwatch.ElapsedMilliseconds); }
/// <summary> /// Initializes a new instance of the <see cref="UnitSystemDependencies"/> class. /// </summary> /// <param name="unitRegistry">The unit registry.</param> /// <param name="lexicalAnalyzer">The lexical analyzer.</param> /// <param name="expressionParser">The expression parser.</param> /// <param name="quantityParser">The quantity parser.</param> /// <param name="unitFactory">The unit factory.</param> /// <param name="quantityOperations">The quantity operations.</param> public UnitSystemDependencies( UnitRegistry unitRegistry, ILexicalAnalyzer lexicalAnalyzer, IExpressionParser expressionParser, IQuantityParser quantityParser, IUnitFactory unitFactory, IQuantityOperations quantityOperations) { this.UnitRegistry = unitRegistry; this.LexicalAnalyzer = lexicalAnalyzer; this.ExpressionParser = expressionParser; this.QuantityParser = quantityParser; this.UnitFactory = unitFactory; this.QuantityOperations = quantityOperations; }
public JoinExpressionParser(IExpressionParser parser) { _parser = parser; }
public IfParser(IExecutorFactory executorFactory, IExpressionParser expressionParser, IBlockParser blockParser) { _executorFactory = executorFactory; _expressionParser = expressionParser; _blockParser = blockParser; }
public AssignmentParser(IExecutorFactory executorFactory, IExpressionParser expressionParser) { _executorFactory = executorFactory; _expressionParser = expressionParser; }
public CalcConverter(FalseToVisibility falseToVisibility, IExpressionParser parser) { FalseToVisibility = falseToVisibility; this.parser = parser; }
public ResourceKeyStack BranchFor(IExpressionParser expression) { var branch = (ResourceKeyStack)MemberwiseClone(); branch._expression = expression; return branch; }
public CalcConverter(IExpressionParser parser) { this.parser = parser; }
private static SqlExpression Parse(string s, IExpressionParser parser) { Exception error; SqlExpression expression; if (!TryParse(s, parser, out expression, out error)) { throw new ExpressionFormatException("Unable to parse the exception.", error); } return expression; }
public CallParser(IExecutorFactory executorFactory, IExpressionParser expressionParser) { _executorFactory = executorFactory; _expressionParser = expressionParser; }
public BinaryExpressionParser(IExpressionParser parser) { _parser = parser; }
public AliasedExpressionParser(IExpressionParser parser) { _parser = parser; }
public ExpressionDocumentation(ResourceKeyStack messagePath, IExpressionParser expr) : this(messagePath, expr, expr.ParsedTypes.Single()) { }
public IQuantityParser CreateParser(IExpressionParser expressionParser, IUnitFactory unitFactory) { return new QuantityParser(expressionParser, unitFactory); }
public DebuggerSession(DebuggerConfiguration config, Stream stream, IExpressionParser parser) : this(config, "main") { this.parser = parser; XmlReaderSettings settings = new XmlReaderSettings (); Assembly ass = Assembly.GetExecutingAssembly (); using (Stream schema = ass.GetManifestResourceStream ("DebuggerConfiguration")) settings.Schemas.Add (null, new XmlTextReader (schema)); XmlReader reader = XmlReader.Create (stream, settings); saved_session = new XmlDocument (); saved_session.Load (reader); reader.Close (); XPathNavigator nav = saved_session.CreateNavigator (); XPathNodeIterator session_iter = nav.Select ( "/DebuggerConfiguration/DebuggerSession[@name='" + Name + "']"); if (!session_iter.MoveNext ()) throw new InternalError (); XPathNodeIterator options_iter = session_iter.Current.Select ("Options/*"); Options = new DebuggerOptions (options_iter); XPathNodeIterator dir_map_iter = session_iter.Current.Select ("DirectoryMap/Map"); while (dir_map_iter.MoveNext ()) { string from = dir_map_iter.Current.GetAttribute ("from", ""); string to = dir_map_iter.Current.GetAttribute ("to", ""); directory_maps.Add (from, to); } LoadSession (nav); }
private void GatherTokens(IExpressionParser expr) { _tokens = new List<ExpressionOperatorSign>(); if (expr.DistinctToken == null) return; _tokens.Add(expr.DistinctToken); if(expr.AdditionalTokens!=null) { _tokens.AddRange(expr.AdditionalTokens); } }
public FunctionExpressionParser(IExpressionParser parser) { _parser = parser; }
protected DebuggerSession(DebuggerConfiguration config, Process process, DebuggerOptions options, string name, IExpressionParser parser, XPathNavigator nav) : this(config, name) { this.main_process = process; this.Options = options; this.parser = parser.Clone (this); XPathNodeIterator event_iter = nav.Select ("Events/*"); LoadEvents (event_iter); XPathNodeIterator display_iter = nav.Select ("Displays/*"); LoadDisplays (display_iter); }
public SelectExpressionParser(IExpressionParser parser) { _parser = parser; }
public ValueGroupExpressionParser(IExpressionParser parser) { _parser = parser; }
/// <summary> /// Initializes the unit system. /// </summary> /// <param name="unitSystemDependencyFactory">The unit system dependency factory.</param> /// <param name="registerUnitAction">The register unit action.</param> public UnitSystemDependencies InitializeUnitSystem( IUnitSystemDependencyFactory unitSystemDependencyFactory, Action<IUnitRegistrar> registerUnitAction) { this.LockedAction( () => { if (!this.isInitialized) { unitSystemDependencyFactory = unitSystemDependencyFactory ?? new UnitSystemDependencyFactory( new ExpressionToFlatRepresentationConverter()); this.unitRegistry = unitSystemDependencyFactory.CreateUnitRegistry(); registerUnitAction?.Invoke(this.unitRegistry); this.expressionParser = unitSystemDependencyFactory.CreateParser(this.unitRegistry); this.lexicalAnalyzer = unitSystemDependencyFactory.CreateLexicalAnalyzer(TokenMatching.CompositeUnit); this.unitFactory = unitSystemDependencyFactory.CreateUnitFactory(this.unitRegistry); this.quantityParser = unitSystemDependencyFactory.CreateParser( this.expressionParser, this.unitFactory); this.quantityOperations = unitSystemDependencyFactory.CreateQuantityOperations(this.unitFactory); this.Dependencies = new UnitSystemDependencies( this.unitRegistry, this.lexicalAnalyzer, this.expressionParser, this.quantityParser, this.unitFactory, this.quantityOperations); this.isInitialized = true; } }); return this.Dependencies; }
public UpdateExpressionParser(IExpressionParser parser) { _parser = parser; }
private void OnSetUp() { this.configurationFactory = A.Fake<IConfigurationFactory>(); this.expressionParser = A.Fake<IExpressionParser>(); this.callExpressionParser = new CallExpressionParser(); this.interceptionAsserter = A.Fake<IInterceptionAsserter>(); Expression<Action<IFoo>> dummyExpression = x => x.Bar(); this.ruleReturnedFromFactory = ServiceLocator.Current.Resolve<ExpressionCallRule.Factory>().Invoke(dummyExpression); this.ruleFactory = x => { return this.ruleReturnedFromFactory; }; this.fakeObjectReturnedFromParser = new FakeManager(); A.CallTo(() => this.expressionParser.GetFakeManagerCallIsMadeOn(A<LambdaExpression>._)).ReturnsLazily(x => this.fakeObjectReturnedFromParser); this.configurationManager = this.CreateManager(); }
private static bool TryParse(string s, IExpressionParser parser, out SqlExpression expression, out Exception error) { if (parser == null) { expression = null; error = new ArgumentNullException("parser"); return false; } try { var result = parser.Parse(s); if (!result.IsValid) { var errors = result.Errors; if (errors.Length == 1) { error = new FormatException(errors[0]); } else { // TODO: aggregate the errors ... error = new FormatException(String.Join(", ", errors)); } expression = null; return false; } expression = result.Expression; error = null; return true; } catch (Exception ex) { error = ex; expression = null; return false; } }
public InsertExpressionParser(IExpressionParser parser) { _parser = parser; }
/// <summary> /// Initializes a new instance of the <see cref="QuantityParser" /> class. /// </summary> /// <param name="expressionParser">The expression parser.</param> /// <param name="unitFactory">The unit factory.</param> public QuantityParser(IExpressionParser expressionParser, IUnitFactory unitFactory) { this.expressionParser = expressionParser; this.unitFactory = unitFactory; }
public FromExpressionParser(IExpressionParser parser) { _parser = parser; }
public static bool TryParse(string s, IExpressionParser parser, out SqlExpression expression) { Exception error; return TryParse(s, parser, out expression, out error); }