public OperationFunction(OperatorBase operatorBase, Dictionary <String, OperandBase> operands)
        {
            try
            {
                this.Operator = operatorBase;
                this.Operands = operands;
            }
            catch (Exception ex)
            {
                Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);

                throw;
            }
        }
        /// <summary>
        /// Parse the string token to get an operand of type Literal, Reference, or Operation.
        /// 1) Literal operands return  the value that they contain.
        /// 2) Reference operands use their own category item criteria
        ///  to narrow down the list of cells to which the formula applies. Then the specific cell's criteria
        ///  is used to identify categories not in the criteria, and use those to narrow down to a single source cell.
        /// 3) Operation operands perform their operation and trigger the evaulation of their child operands.
        /// </summary>
        /// <param name="token"></param>
        /// <param name="operand"></param>
        /// <param name="errorMessage"></param>
        /// <returns></returns>
        private Boolean ParseToken(String token, ref OperandBase operand, ref String errorMessage)
        {
            Boolean returnValue = default(Boolean);

            String[]      tokens          = default(String[]);
            String        leftToken       = default(String);
            String        rightToken      = default(String);
            Boolean       isFoundOperator = default(Boolean);
            OperatorBase  foundOperator   = default(OperatorBase);
            OperandBase   leftOperand     = default(OperandBase);
            OperandBase   rightOperand    = default(OperandBase);
            OperationBase operation       = default(OperationBase);

            try
            {
                //look for operators, if any, in reverse precedence order
                foreach (OperatorBase op in arithmeticOperators)
                {
                    if (token.Contains(op.Name))
                    {
                        isFoundOperator = true;
                        foundOperator   = op;

                        break;
                    }
                }

                //create an array of one or two sub-tokens
                if (isFoundOperator)
                {
                    //split into 2 parts only
                    tokens = token.Split(new Char[] { foundOperator.Name[0] }, 2);
                }
                else
                {
                    //create list with single item
                    String[] newList = { token };
                    tokens = newList;
                }

                //process sub-tokens
                if (tokens.Length == 0)
                {
                    throw new ArgumentException(String.Format("Incorrectly formatted formula; there does not appear to be an operand: '{0}'", token));
                }
                else if (tokens.Length == 1)
                {
                    //no operator; process single operand
                    leftToken = tokens[0].Trim();
                    if (!ParseOperand(leftToken, ref leftOperand, ref errorMessage))
                    {
                        throw new ApplicationException(errorMessage);
                    }
                    operand = leftOperand;

                    returnValue = true;
                }
                else if (tokens.Length == 2)
                {
                    //operator found; process dual operands with recursive call
                    leftToken = tokens[0].Trim();
                    if (!ParseToken(leftToken, ref leftOperand, ref errorMessage))
                    {
                        throw new ApplicationException(errorMessage);
                    }

                    rightToken = tokens[1].Trim();
                    if (!ParseToken(rightToken, ref rightOperand, ref errorMessage))
                    {
                        throw new ApplicationException(errorMessage);
                    }

                    //create operation from left/right operands and operator, and create OperandOperation
                    //create OperationBinary which configures 2 OperandBase dictionary entries called Left, Right.
                    operation = new OperationBinary();
                    operation.Operands["Left"]  = leftOperand;
                    operation.Operands["Right"] = rightOperand;
                    operation.Operator          = foundOperator;

                    operand = new OperandOperation(operation);

                    returnValue = true;
                }
                else if (tokens.Length > 2)
                {
                    throw new ArgumentException(String.Format("Unexpected formula format: '{0}'", token));
                }
            }
            catch (Exception ex)
            {
                errorMessage = ex.Message;
                Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
                //throw;
            }
            return(returnValue);
        }
        /// <summary>
        /// Parse the string token to get an operand of type Operation,
        /// whose operation is of type Function(?),
        /// and where the operator is the defined in the token.
        /// </summary>
        /// <param name="token"></param>
        /// <param name="operand"></param>
        /// <param name="errorMessage"></param>
        /// <returns></returns>
        private Boolean ParseFunction(String token, ref OperandBase operand, ref String errorMessage)
        {
            Boolean      returnValue        = default(Boolean);
            Boolean      isFoundOperator    = default(Boolean);
            OperatorBase foundOperator      = default(OperatorBase);
            Int32        countOfLeftBraces  = default(Int32);
            Int32        countOfRightBraces = default(Int32);
            Regex        regEx           = default(Regex);
            Match        match           = default(Match);
            String       parametersToken = default(String);

            String[] parameterTokens   = default(String[]);
            String   functionNameToken = default(String);
            Dictionary <String, OperandBase> parameterDictionary = default(Dictionary <String, OperandBase>);
            OperandBase parameterOperand = default(OperandBase);
            Int32       parameterIndex   = default(Int32);

            try
            {
                countOfLeftBraces = (from Char ch in token
                                     where ch == Formula.LeftBrace
                                     select ch).Count();
                countOfRightBraces = (from Char ch in token
                                      where ch == Formula.RightBrace
                                      select ch).Count();
                if ((countOfLeftBraces > 0) || (countOfRightBraces > 0))
                {
                    //braces found

                    if (countOfLeftBraces != countOfRightBraces)
                    {
                        //mismatched pair
                        throw new ApplicationException(String.Format("Mis-matched braces in token: '{0}'", token));
                    }

                    //get parameters

                    regEx = new Regex(Formula.RegExFindInnermostBracesAndContents);
                    match = regEx.Match(token);
                    if ((match.Value == null) || (match.Value == String.Empty))
                    {
                        //pair did not match pattern
                        throw new ApplicationException(String.Format("Braces in token not formatted correctly: '{0}'", token));
                    }

                    parametersToken = match.Value.Replace(Formula.LeftBrace.ToString(), String.Empty).Replace(Formula.RightBrace.ToString(), String.Empty);
                    if ((parametersToken == null) || (parametersToken == String.Empty))
                    {
                        //pair did not contain an expression
                        throw new ApplicationException(String.Format("Value in parenthesis in token not formatted correctly: '{0}'", token));
                    }

                    parameterTokens = parametersToken.Split(Formula.FunctionParameterDelimiter);
                    if (parameterTokens.Length == 0)
                    {
                        //pair did not contain any values
                        throw new ApplicationException(String.Format("Value in parenthesis in token not formatted correctly: '{0}'", token));
                    }

                    //get function name

                    regEx = new Regex(Formula.RegExFindFunctionNameDelimitersAndContents);
                    match = regEx.Match(token);
                    if ((match.Value == null) || (match.Value == String.Empty))
                    {
                        //pair did not match pattern
                        throw new ApplicationException(String.Format("Function name delimiters in token not formatted correctly: '{0}'", token));
                    }

                    functionNameToken = match.Value.Replace(Formula.FunctionIndicator.ToString(), String.Empty).Replace(Formula.LeftBrace.ToString(), String.Empty);
                    if ((functionNameToken == null) || (functionNameToken == String.Empty))
                    {
                        //pair did not contain an expression
                        throw new ApplicationException(String.Format("Function name in token not formatted correctly: '{0}'", token));
                    }

                    //look for operators, if any
                    foreach (OperatorBase op in functionOperators)
                    {
                        if (functionNameToken.ToUpper().Contains(op.Name))
                        {
                            isFoundOperator = true;
                            foundOperator   = op;

                            break;
                        }
                    }

                    //get function

                    if (isFoundOperator)
                    {
                        //build operation operand with function operation consisting of operator and each parameter token parsed into an operand.
                        parameterDictionary = new Dictionary <String, OperandBase>();
                        foreach (String parameterToken in parameterTokens)
                        {
                            if (!ParseToken(parameterToken, ref parameterOperand, ref errorMessage))
                            {
                                //error parsing operand token
                                throw new ApplicationException(String.Format("Unable to parse parameter '{0}' in function token '{1}'.", parameterToken, token));
                            }
                            parameterDictionary.Add(String.Format("Value{0}", parameterIndex++), parameterOperand);
                        }

                        //set operand to new OperandOperation of type OperationFunction using operator of type OperatorXXX (foundOperator)
                        operand = new OperandOperation(new OperationFunction(foundOperator, parameterDictionary));
                    }
                    else
                    {
                        throw new ApplicationException(String.Format("Unable to find function: '{0}'", token));
                    }
                }
                else
                {
                    throw new ApplicationException(String.Format("Unable to find braces for parameters: '{0}'", token));
                }

                returnValue = true;
            }
            catch (Exception ex)
            {
                Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
                //throw;
            }
            return(returnValue);
        }