예제 #1
0
        internal ArgumentMatcher(IExpressionHelper expressionHelper, IItIsMatcher itIsMatcher)
        {
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);
            ArgumentChecker.NotNull(itIsMatcher, () => itIsMatcher);

            _expressionHelper = expressionHelper;
            _itIsMatcher = itIsMatcher;
        }
예제 #2
0
        internal ArgumentMatcher(IExpressionHelper expressionHelper, IItIsMatcher itIsMatcher)
        {
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);
            ArgumentChecker.NotNull(itIsMatcher, () => itIsMatcher);

            _expressionHelper = expressionHelper;
            _itIsMatcher      = itIsMatcher;
        }
예제 #3
0
 public AlbumService(IAlbumRepository albumRepository,
                     IExpressionHelper expressionHelper,
                     IBlobStorageService blobStorageService)
 {
     _expressionHelper       = expressionHelper;
     _blobStorageService     = blobStorageService;
     _albumGenericRepository = albumRepository as IGenericRepository <Album>;
 }
        public static IExpressionHelper GetInstance()
        {
            if (_helper == null)
            {
                _helper = new ExpressionHelper();
            }

            return(_helper);
        }
예제 #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Interceptor" /> class.
        /// </summary>
        /// <param name="setupMatcher">The setup matcher.</param>
        /// <param name="invocationTracker">The invocation tracker.</param>
        /// <param name="expressionHelper">The expression helper.</param>
        internal Interceptor(ISetupMatcher setupMatcher, IInvocationTracker invocationTracker,
                             IExpressionHelper expressionHelper)
        {
            ArgumentChecker.NotNull(setupMatcher, () => setupMatcher);
            ArgumentChecker.NotNull(invocationTracker, () => invocationTracker);
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);

            _setupMatcher      = setupMatcher;
            _invocationTracker = invocationTracker;
            _expressionHelper  = expressionHelper;
        }
예제 #6
0
        internal SetupExtractor(
            IMethodDisassembler methodDisassembler,
            IExpressionDecompiler <Expression> expressionDecompiler,
            IExpressionHelper expressionHelper)
        {
            ArgumentChecker.NotNull(methodDisassembler, () => methodDisassembler);
            ArgumentChecker.NotNull(expressionDecompiler, () => expressionDecompiler);
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);

            _methodDisassembler   = methodDisassembler;
            _expressionDecompiler = expressionDecompiler;
            _expressionHelper     = expressionHelper;
        }
예제 #7
0
        internal SetupExtractor(
            IMethodDisassembler methodDisassembler,
            IExpressionDecompiler<Expression> expressionDecompiler,
            IExpressionHelper expressionHelper)
        {
            ArgumentChecker.NotNull(methodDisassembler, () => methodDisassembler);
            ArgumentChecker.NotNull(expressionDecompiler, () => expressionDecompiler);
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);

            _methodDisassembler = methodDisassembler;
            _expressionDecompiler = expressionDecompiler;
            _expressionHelper = expressionHelper;
        }
 public ExpressionHelperTests()
 {
     _expressionHelper = new ExpressionHelper(ParsingConfig.Default);
 }
예제 #9
0
        internal SetupManager(IExpressionHelper expressionHelper)
        {
            ArgumentChecker.NotNull(expressionHelper, () => expressionHelper);

            _expressionHelper = expressionHelper;
        }
 public void SetUp()
 {
     _helper = MockRepository.GenerateMock<IExpressionHelper>();
     _controller = new HomeController(_helper);
 }
예제 #11
0
 public ASTBuilder(IExpressionHelper expressionHelper)
 {
     _expressionHelper = expressionHelper;
 }
 public HomeController(IExpressionHelper helper)
 {
     _helper = helper;
 }
        public void Initialize()
        {
            _expressionHelper = new ExpressionHelper();
            var matchOpen = new HashSet<char> { '<' };
            var matchClose = new HashSet<char> { '>' };
            var matchSlash = new HashSet<char> { '/' };
            var matchLetter = Utilities.AllLetters();
            var matchLetterOrDigit = Utilities.Union(matchLetter, Utilities.AllDigits());
            var matchw = new HashSet<char> { 'w' };
            var matchh = new HashSet<char> { 'h' };
            var matchi = new HashSet<char> { 'i' };
            var matchl = new HashSet<char> { 'l' };
            var matche = new HashSet<char> { 'e' };
            var matchf = new HashSet<char> { 'f' };
            var matchSpace = Utilities.AllWhitespace();

            //_parserGenerator = new TerminalClassifier<char>();
            // Simple XML tags (no attributes)
            _openTag = new Terminal<char>
            {
                Name = "OpenTag",
                ValueType = typeof(string)
            };
            _closeTag = new Terminal<char>
            {
                Name = "CloseTag",
                ValueType = typeof(string)
            };
            _leafTag = new Terminal<char>
            {
                Name = "LeafTag",
                ValueType = typeof(string)
            };

            // Other terminals commonly found in programming languages.
            _if = new Terminal<char>
            {
                Name = "If",
                ValueType = typeof(void)
            };

            _while = new Terminal<char>
            {
                Name = "While",
                ValueType = typeof(void)
            };

            _identifier = new Terminal<char>
            {
                Name = "Identifier",
                ValueType = typeof(string)
            };

            _whitespace = new Terminal<char>
            {
                Name = "Whitespace",
                ValueType = typeof(void)
            };

            var openTagAccept = new FiniteAutomatonState<char>
            {
                IsAccepting = true,
                IsRejecting = false,
            };
            var closeTagAccept = new FiniteAutomatonState<char>
            {
                IsAccepting = true,
                IsRejecting = false
            };
            var leafTagAccept = new FiniteAutomatonState<char>
            {
                IsAccepting = true,
                IsRejecting = false
            };

            var leafClose = new FiniteAutomatonState<char>
            {
                Transitions = new[] {new FiniteAutomatonStateTransition<char> {
                    Characters = matchClose,
                    Target = leafTagAccept
                }
                }
            };

            var leafName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchSlash,
                        Target = leafClose},
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetterOrDigit}}
            };
            leafName.Transitions.Skip(1).First().Target = leafName;

            var beginLeafName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetter,
                        Target = leafName}}
            };

            var leafOpen = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchOpen,
                        Target = beginLeafName}
                }
            };

            var closeClose = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchClose,
                        Target = closeTagAccept}
                }
            };

            var closeName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char>
                    {
                        MatchEpsilon = true,
                        Target = closeClose
                    },
                    new FiniteAutomatonStateTransition<char>
                    {
                        Characters = matchLetterOrDigit
                    }
                }
            };
            closeName.Transitions.Skip(1).First().Target = closeName;

            var beginCloseName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char>
                    {
                        Characters = matchLetter,
                        Target = closeName
                    }
                }
            };
            var closeSlash = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchSlash,
                        Target = beginCloseName}
                }
            };
            var closeOpen = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchOpen,
                        Target = closeSlash}}
            };

            var openName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchClose,
                        Target = openTagAccept},
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetterOrDigit}
                }
            };
            openName.Transitions.Skip(1).First().Target = openName;

            var beginOpenName = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetter,
                        Target = openName
                    }
                }
            };

            var openOpen = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchOpen,
                        Target = beginOpenName}}
            };

            _openTag.InitialState = openOpen;
            _closeTag.InitialState = closeOpen;
            _leafTag.InitialState = leafOpen;

            // Keywords & identifiers
            var acceptIf = new FiniteAutomatonState<char>
            {
                IsAccepting = true
            };
            var fIf = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchf,
                        Target = acceptIf
                    }
                }
            };
            var iIf = new FiniteAutomatonState<char>
            {

                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchi,
                        Target = fIf
                    }
                }
            };
            _if.InitialState = iIf;

            var acceptWhile = new FiniteAutomatonState<char>
            {
                IsAccepting = true
            };

            var eWhile = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matche,
                        Target = acceptWhile
                    }
                }
            };

            var lWhile = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchl,
                        Target = eWhile}
                }
            };

            var iWhile = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchi,
                        Target = lWhile}
                }
            };

            var hWhile = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchh,
                        Target = iWhile}
                }
            };

            var wWhile = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchw,
                        Target = hWhile}
                }
            };
            _while.InitialState = wWhile;

            var identifierChar = new FiniteAutomatonState<char>
            {
                IsAccepting = true,
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetterOrDigit
                    }
                }
            };
            identifierChar.Transitions.First().Target = identifierChar;

            var identifierBegin = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchLetter,
                        Target = identifierChar
                    }
                }
            };
            _identifier.InitialState = identifierBegin;

            var whitespaceChar = new FiniteAutomatonState<char>
            {
                IsAccepting = true,
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchSpace
                    }
                }
            };

            whitespaceChar.Transitions.First().Target = whitespaceChar;

            var firstWhitespace = new FiniteAutomatonState<char>
            {
                Transitions = new[] {
                    new FiniteAutomatonStateTransition<char> {
                        Characters = matchSpace,
                        Target=whitespaceChar
                    }
                }
            };
            _whitespace.InitialState = firstWhitespace;
        }
 public void SetUp()
 {
     _client = MockRepository.GenerateMock<IFractionalCalculatorRestClient>();
     _helper = new ExpressionHelper(_client);
 }