コード例 #1
0
 public FakeConfigurationManager(IConfigurationFactory configurationFactory, IExpressionParser parser, ExpressionCallRule.Factory callRuleFactory, IProxyGenerator proxyGenerator)
 {
     this.configurationFactory = configurationFactory;
     this.expressionParser     = parser;
     this.ruleFactory          = callRuleFactory;
     this.proxyGenerator       = proxyGenerator;
 }
コード例 #2
0
        public ResourceKeyStack BranchFor(IExpressionParser expression)
        {
            var branch = (ResourceKeyStack)MemberwiseClone();

            branch._expression = expression;
            return(branch);
        }
コード例 #3
0
        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);
            }
        }
コード例 #4
0
        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();
        }
コード例 #5
0
        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));
        }
コード例 #6
0
        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

                )
        {
        }
コード例 #7
0
 public TwisterParser(
     Func <IEnumerable <IToken>, ITokenMatcher> createTokenMatcher,
     IExpressionParser expressionParser)
 {
     _createTokenMatcher = createTokenMatcher;
     _expressionParser   = expressionParser;
 }
コード例 #8
0
 public FunctionEvaluator(IExpressionParser evaluator, string name, IOption <char> optionalFirst, IJTokenEvaluator[] parameters)
 {
     this.name          = name;
     this.optionalFirst = optionalFirst;
     this.parameters    = parameters;
     this.evaluator     = evaluator;
 }
コード例 #9
0
            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();
            }
コード例 #10
0
        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;
        }
コード例 #11
0
ファイル: Parser.cs プロジェクト: wimh/monkey-cs
        public Parser(Lexer lexer, IExpressionParser expressionParser)
        {
            _lexer            = lexer;
            _expressionParser = expressionParser;

            _expressionParser.ParserError += (s, a) => AddError(a);
        }
コード例 #12
0
 public override Expression GetExpression(IExpressionParser factory)
 {
     // add constraints for activity type
     return(Expression.AndExpression(
                factory.Parse($"{TurnPath.ACTIVITY}.type == '{this.Type}'"),
                base.GetExpression(factory)));
 }
コード例 #13
0
        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));
        }
コード例 #14
0
ファイル: TokenNode.cs プロジェクト: asaa62820/Project
        public string Render(IExpressionParser parser, ITemplateContext context)
        {
            StringBuilder output = new StringBuilder();

            this.Render(parser, context, output);
            return(output.ToString());
        }
コード例 #15
0
ファイル: TokenNode.cs プロジェクト: asaa62820/Project
 public void Render(IExpressionParser parser, ITemplateContext context, StringBuilder output)
 {
     foreach (TokenNode node in this.ChildNodes)
     {
         node.Evaluate(parser, context, output);
     }
 }
コード例 #16
0
        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)));
        }
コード例 #17
0
 public SyntaxProcessor(IExpressionParser expressionParser,
                        ISyntaxTokenParser tokenParser,
                        ISyntaxAnalyzer syntaxAnalyzer)
 {
     _expressionParser = expressionParser;
     _tokenParser      = tokenParser;
     _syntaxAnalyzer   = syntaxAnalyzer;
 }
コード例 #18
0
 public ExpressionDocumentation(ResourceKeyStack messagePath, IExpressionParser expr, Type type)
 {
     GatherTokens(expr);
     _name = type.Name;
     _messagePath = messagePath.BranchFor(expr);
     _category = CategoryHelper.GetCategory(type);
     _description = _messagePath.Description;
 }
コード例 #19
0
 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);
 }
コード例 #20
0
 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);
 }
コード例 #21
0
        public EFExpressionParser(IExpressionParser expParser, IEnumerablePrinter printer)
        {
            expParser.CheckNull(nameof(expParser));
            printer.CheckNull(nameof(printer));

            _expParser = expParser;
            _printer   = printer;
        }
コード例 #22
0
 public ExpressionDocumentation(ResourceKeyStack messagePath, IExpressionParser expr, Type type)
 {
     GatherTokens(expr);
     _name        = type.Name;
     _messagePath = messagePath.BranchFor(expr);
     _category    = CategoryHelper.GetCategory(type);
     _description = _messagePath.Description;
 }
コード例 #23
0
        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);
        }
コード例 #24
0
 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;
 }
コード例 #25
0
        /// <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);
        }
コード例 #26
0
        /// <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 =&gt; x.IsDeleted == true"
        /// Other examples:
        /// x =&gt; x.ChildEntity.Name
        /// x =&gt; 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);
        }
コード例 #27
0
 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();
 }
コード例 #28
0
        //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)));
            }
        }
コード例 #29
0
ファイル: CalcBinding.cs プロジェクト: gentoos163/CalcBinding
        public static void ReplaceExpressionParser(IExpressionParser expressionParser)
        {
            if (expressionParser == null)
            {
                throw new ArgumentNullException(nameof(expressionParser));
            }

            _parser = new Lazy <IExpressionParser>(() => expressionParser);
        }
コード例 #30
0
 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;
 }
コード例 #31
0
        /// <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;
        }
コード例 #32
0
ファイル: DebuggerSession.cs プロジェクト: baulig/debugger
        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));
        }
コード例 #33
0
		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);
		}
コード例 #34
0
 /// <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;
 }
コード例 #35
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public JoinExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #36
0
ファイル: IfParser.cs プロジェクト: mdcuesta/Ongle
 public IfParser(IExecutorFactory executorFactory, IExpressionParser expressionParser, IBlockParser blockParser)
 {
     _executorFactory = executorFactory;
     _expressionParser = expressionParser;
     _blockParser = blockParser;
 }
コード例 #37
0
ファイル: AssignmentParser.cs プロジェクト: mdcuesta/Ongle
 public AssignmentParser(IExecutorFactory executorFactory, IExpressionParser expressionParser)
 {
     _executorFactory = executorFactory;
     _expressionParser = expressionParser;
 }
コード例 #38
0
ファイル: CalcConverter.cs プロジェクト: WELL-E/CalcBinding
 public CalcConverter(FalseToVisibility falseToVisibility, IExpressionParser parser)
 {
     FalseToVisibility = falseToVisibility;
     this.parser = parser;
 } 
コード例 #39
0
ファイル: ResourceKeyStack.cs プロジェクト: rslijp/sharptiles
 public ResourceKeyStack BranchFor(IExpressionParser expression)
 {
     var branch = (ResourceKeyStack)MemberwiseClone();
     branch._expression = expression;
     return branch;
 }
コード例 #40
0
ファイル: CalcConverter.cs プロジェクト: WELL-E/CalcBinding
 public CalcConverter(IExpressionParser parser)
 {
     this.parser = parser;        
 }
コード例 #41
0
ファイル: SqlExpression.cs プロジェクト: deveel/deveeldb
        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;
        }
コード例 #42
0
ファイル: CallParser.cs プロジェクト: mdcuesta/Ongle
 public CallParser(IExecutorFactory executorFactory, IExpressionParser expressionParser)
 {
     _executorFactory = executorFactory;
     _expressionParser = expressionParser;
 }
コード例 #43
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public BinaryExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #44
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public AliasedExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #45
0
 public ExpressionDocumentation(ResourceKeyStack messagePath, IExpressionParser expr)
     : this(messagePath, expr, expr.ParsedTypes.Single())
 {
 }
コード例 #46
0
 public IQuantityParser CreateParser(IExpressionParser expressionParser, IUnitFactory unitFactory)
 {
     return new QuantityParser(expressionParser, unitFactory);
 }
コード例 #47
0
ファイル: DebuggerSession.cs プロジェクト: baulig/debugger
        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);
        }
コード例 #48
0
 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);
     }
 }
コード例 #49
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public FunctionExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #50
0
ファイル: DebuggerSession.cs プロジェクト: baulig/debugger
        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);
        }
コード例 #51
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public SelectExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #52
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public ValueGroupExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #53
0
        /// <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;
        }
コード例 #54
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public UpdateExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #55
0
        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();
        }
コード例 #56
0
ファイル: SqlExpression.cs プロジェクト: deveel/deveeldb
        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;
            }
        }
コード例 #57
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public InsertExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #58
0
 /// <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;
 }
コード例 #59
0
ファイル: MsSqlProcessor.cs プロジェクト: worldspawn/mascis
 public FromExpressionParser(IExpressionParser parser)
 {
     _parser = parser;
 }
コード例 #60
0
ファイル: SqlExpression.cs プロジェクト: deveel/deveeldb
 public static bool TryParse(string s, IExpressionParser parser, out SqlExpression expression)
 {
     Exception error;
     return TryParse(s, parser, out expression, out error);
 }