//constructor used for testing purpose only
        public ExpressionBuilder(

            IParenthesize parenthesizer,
            string expression,
            int type

            ) : this(parenthesizer) {
            if (type < 0 || type > 5)
            {
                throw new ArgumentException("Invalid Key Type.");
            }

            var typeTable = new Dictionary <int, KeyType>()
            {
                { 0, KeyType.Value },
                { 1, KeyType.Unary },
                { 2, KeyType.Binary },
                { 3, KeyType.Left },
                { 4, KeyType.Right },
                { 5, KeyType.Empty },
            };

            if (expression != null)
            {
                Buffer.Add(expression);
            }

            KeyHistory.Add(typeTable[type]);
        }
 public ExpressionBuilder(IParenthesize parenthesizer)
 {
     Buffer     = new Deque <string>();
     KeyHistory = new Deque <KeyType>()
     {
         KeyType.Empty
     };
     Parenthesizer = parenthesizer;
 }
        public void Setup()
        {
            buffer            = new InputBuffer();
            lookup            = new OperatorLookup();
            unitConverter     = new AngleConverter();
            operatorConverter = new OperatorConverter(lookup.Operators, lookup.Unary);
            parenthesizer     = new Parenthesizer(lookup.Precedence);
            builder           = new ExpressionBuilder(parenthesizer);
            parser            = new ExpressionParser(operatorConverter);
            evaluator         = new Evaluator(unitConverter, operatorConverter, lookup);
            memory            = new MemoryStorage();

            calculator = new ScientificCalculator(

                buffer,
                lookup,
                unitConverter,
                operatorConverter,
                builder,
                parser,
                evaluator,
                memory
                );
        }