private Bucket(IOperand operand)
        {
            if (operand == null)
                throw new ArgumentNullException("operand");

            _operand = operand;
        }

 protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
     IOperand fieldRefOperand, IOperand valueOperand)
     : base(operationResultBuilder)
 {
     this.fieldRefOperand = fieldRefOperand;
     this.valueOperand = valueOperand;
 }

 protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
     IOperand columnOperand, IOperand valueOperand)
     : base(operationResultBuilder)
 {
     this.ColumnOperand = columnOperand;
     this.ValueOperand = valueOperand;
 }

        public void ReplaceLastOperand(IOperand operand)
        {
            if (Operands.Count == 0)
            {
                throw new InvalidOperationException("There are no operands to replace.");
            }


            int stealIndex = Operands.Count - 1;
            
            NativeOperation op = Operands[stealIndex] as NativeOperation;

            // Check if the "steal" target is itself something that we can steal from, if so, 
            // recurse. This rule of checkiung association type is a bit confusing, this should
            // be a property?

            if (op !=null && op.Operands.Count > 1 && op.AssociationType == AssociationType.Multiplicaton)
            {
                IOperation func = (IOperation)op;
                func.ReplaceLastOperand(operand);
            }
            else
            {
                _Operands[Operands.Count - 1] = operand;
            }
        }

 public IOperand GreaterThan(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.> : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((long)this.Value > (long)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

 /// IComparisonOperators methods.  Return values are always BooleanOperands type
 public IOperand EqualTo(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.== : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = (long)this.Value == (long)((Operand)rhs).Value;
     return oprResult;
 }

 public IOperand Divide(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.Divide : rhs");
     LongOperand oprResult = new LongOperand("Result", Type.GetType("System.Int64"));
     oprResult.Value = (long)this.Value / (long)((Operand)rhs).Value;
     return oprResult;
 }

 public IOperand LessThanOrEqualTo(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.<= : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((long)this.Value <= (long)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

 public IOperand OR(IOperand rhs)
 {
     if (!(rhs is BoolOperand))
         throw new RPN_Exception("Argument invalid in BoolOperand.|| : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((bool)this.Value || (bool)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

        internal static bool Match(PackageItem package, IOperand operand)
        {
            var expression = operand as Expression;

            if (expression != null)
                return MatchExpression(package, expression);
            return MatchPredicate(package, operand);
        }

        public void ReplaceLastOperand(IOperand operand)
        {
            if (Operands.Count == 0)
            {
                throw new InvalidOperationException("There are no operands to replace.");
            }

            _Operands[Operands.Count - 1] = operand;
        }

 protected override IOperand CopyTo(IOperand operand)
 {
     NativeOperation target = (NativeOperation)operand;
     foreach (var item in _Operators)
     {
         target._Operators.Add(item);
     }
     return base.CopyTo(target);
 }

 public DateRangesOverlapOperation(IOperationResultBuilder operationResultBuilder,
     IOperand startFieldRefOperand, IOperand stopFieldRefOperand, IOperand recurrenceFieldRefOperand, IOperand dateTimeOperand)
     : base(operationResultBuilder)
 {
     this.startFieldRefOperand = startFieldRefOperand;
     this.stopFieldRefOperand = stopFieldRefOperand;
     this.recurrenceFieldRefOperand = recurrenceFieldRefOperand;
     this.dateTimeOperand = dateTimeOperand;
 }

        private static bool MatchPredicate(PackageItem package, IOperand predicate)
        {
            var unaryPredicate = predicate as UnaryPredicate;
            if (unaryPredicate != null)
                return MatchPredicate(package, unaryPredicate);

            var binaryPredicate = predicate as BinaryPredicate;
            if (binaryPredicate != null)
                return MatchPredicate(package, binaryPredicate);

            return true;
        }

        private Range(IOperand min = null, IOperand max = null, bool minInclusive = false, bool maxInclusive = false)
        {
            if (min == null && max == null)
                throw new ArgumentException("Min and max cannot both be null.");

            // TODO check min < max?

            Min = min;
            Max = max;
            MinInclusive = minInclusive;
            MaxInclusive = maxInclusive;
        }

 //bool bBinaryOperator = true;
 //{"&&", "||"}
 public override IOperand Eval(IOperand lhs, IOperand rhs)
 {
     if (!(lhs is ILogicalOperations))
         throw new RPN_Exception("Argument invalid in LogicalOperator.Eval - Invalid Expression : lhs");
     switch (m_szOperator)
     {
         case "&&":
             return ((ILogicalOperations)lhs).AND(rhs);
         case "||":
             return ((ILogicalOperations)lhs).OR(rhs);
     }
     throw new RPN_Exception("Unsupported Logical operation " + m_szOperator);
 }

 // ----- Field Ref Operand -----
 public IOperand CreateFieldRefOperand(Expression expr, IOperand valueOperand)
 {
     if (expr is UnaryExpression)
     {
         expr = ((UnaryExpression)expr).Operand;
     }
     var methodCallExpression = expr as MethodCallExpression;
     var argumentExpression = methodCallExpression.Arguments[0];
     if (argumentExpression is ConstantExpression)
     {
         return this.createFieldRefOperandFromConstantExpression(argumentExpression as ConstantExpression,
             valueOperand);
     }
     return this.createFieldRefOperandFromNonConstantExpression(argumentExpression, valueOperand);
 }

 //bool bBinaryOperator = true;
 public override IOperand Eval(IOperand lhs, IOperand rhs)
 {
     if (!(lhs is IArithmeticOperations))
         throw new RPN_Exception("Argument invalid in ArithmeticOperator.Eval - Invalid Expression : lhs");
     switch (m_szOperator)
     {
         case "+":
             return ((IArithmeticOperations)lhs).Plus(rhs);
         case "-":
             return ((IArithmeticOperations)lhs).Minus(rhs);
         case "*":
             return ((IArithmeticOperations)lhs).Multiply(rhs);
         case "/":
             return ((IArithmeticOperations)lhs).Divide(rhs);
         case "%":
             return ((IArithmeticOperations)lhs).Modulo(rhs);
     }
     throw new RPN_Exception("Unsupported Arithmetic operation " + m_szOperator);
 }

 //bool bBinaryOperator = true;
 //{"==", "!=","<", "<=", ">", ">="}
 public override IOperand Eval(IOperand lhs, IOperand rhs)
 {
     if (!(lhs is IComparisonOperations))
         throw new RPN_Exception("Argument invalid in ComparisonOperator.Eval - Invalid Expression : lhs");
     switch (m_szOperator)
     {
         case "==":
             return ((IComparisonOperations)lhs).EqualTo(rhs);
         case "!=":
             return ((IComparisonOperations)lhs).NotEqualTo(rhs);
         case "<":
             return ((IComparisonOperations)lhs).LessThan(rhs);
         case "<=":
             return ((IComparisonOperations)lhs).LessThanOrEqualTo(rhs);
         case ">":
             return ((IComparisonOperations)lhs).GreaterThan(rhs);
         case ">=":
             return ((IComparisonOperations)lhs).GreaterThanOrEqualTo(rhs);
     }
     throw new RPN_Exception("Unsupported Comparison operation " + m_szOperator);
 }

        public IOperand Evaluate(IOperand op1)
        {
            if (DoubleDouble != null)
            {
                if (op1.Type == typeof(double))
                {
                    var dOp1 = op1 as GenericOperand<double>;
                    return new GenericOperand<double>(DoubleDouble(dOp1.Value));
                }
            }

            if (StringDouble != null)
            {
                if (op1.Type == typeof(string))
                {
                    var dOp1 = op1 as GenericOperand<string>;
                    return new GenericOperand<double>(StringDouble(dOp1.Value));
                }
            }

            if (DoubleTimespan != null)
            {
                if (op1.Type == typeof(double))
                {
                    var dOp1 = op1 as GenericOperand<double>;
                    return new GenericOperand<TimeSpan>(DoubleTimespan(dOp1.Value));
                }
            }

            if (TimespanDouble != null)
            {
                if (op1.Type == typeof(TimeSpan))
                {
                    var dOp1 = op1 as GenericOperand<TimeSpan>;
                    return new GenericOperand<double>(TimespanDouble(dOp1.Value));
                }
            }

            throw new ExpressionException(_name2 + " operator used incorrectly.");
        }