Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / Literal.cs / 1305376 / Literal.cs
// ---------------------------------------------------------------------------- // Copyright (C) 2005 Microsoft Corporation All Rights Reserved // --------------------------------------------------------------------------- #define CODE_ANALYSIS using System.CodeDom; using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Reflection; using System.Workflow.ComponentModel; using System.Workflow.ComponentModel.Compiler; using System.Workflow.Activities.Common; namespace System.Workflow.Activities.Rules { #region Literal Class ////// Represents a typed literal value and is the base class for all type specific literal classes /// internal abstract class Literal { #region Properties ////// A delegate for literal factory methods /// private delegate Literal LiteralMaker(object literalValue); ////// Collection of literal factory methods indexed by type /// static private Dictionarytypes = CreateMakersDictionary(); /// /// The type of the literal /// protected internal Type m_type; ////// Get the boxed literal /// internal abstract object Value { get; } ////// Group types by similar characteristics so we can check if comparisons succeed /// [Flags()] enum TypeFlags { SignedNumbers = 0x01, UnsignedNumbers = 0x02, ULong = 0x04, Float = 0x08, Decimal = 0x10, String = 0x20, Bool = 0x40 }; ////// Collection of TypeFlags for the supported value types indexed by type /// private static DictionarysupportedTypes = CreateTypesDictionary(); private static Dictionary CreateMakersDictionary() { // Create the literal class factory delegates Dictionary dictionary = new Dictionary (32); dictionary.Add(typeof(byte), new LiteralMaker(Literal.MakeByte)); dictionary.Add(typeof(sbyte), new LiteralMaker(Literal.MakeSByte)); dictionary.Add(typeof(short), new LiteralMaker(Literal.MakeShort)); dictionary.Add(typeof(int), new LiteralMaker(Literal.MakeInt)); dictionary.Add(typeof(long), new LiteralMaker(Literal.MakeLong)); dictionary.Add(typeof(ushort), new LiteralMaker(Literal.MakeUShort)); dictionary.Add(typeof(uint), new LiteralMaker(Literal.MakeUInt)); dictionary.Add(typeof(ulong), new LiteralMaker(Literal.MakeULong)); dictionary.Add(typeof(float), new LiteralMaker(Literal.MakeFloat)); dictionary.Add(typeof(double), new LiteralMaker(Literal.MakeDouble)); dictionary.Add(typeof(char), new LiteralMaker(Literal.MakeChar)); dictionary.Add(typeof(string), new LiteralMaker(Literal.MakeString)); dictionary.Add(typeof(decimal), new LiteralMaker(Literal.MakeDecimal)); dictionary.Add(typeof(bool), new LiteralMaker(Literal.MakeBool)); dictionary.Add(typeof(byte?), new LiteralMaker(Literal.MakeByte)); dictionary.Add(typeof(sbyte?), new LiteralMaker(Literal.MakeSByte)); dictionary.Add(typeof(short?), new LiteralMaker(Literal.MakeShort)); dictionary.Add(typeof(int?), new LiteralMaker(Literal.MakeInt)); dictionary.Add(typeof(long?), new LiteralMaker(Literal.MakeLong)); dictionary.Add(typeof(ushort?), new LiteralMaker(Literal.MakeUShort)); dictionary.Add(typeof(uint?), new LiteralMaker(Literal.MakeUInt)); dictionary.Add(typeof(ulong?), new LiteralMaker(Literal.MakeULong)); dictionary.Add(typeof(float?), new LiteralMaker(Literal.MakeFloat)); dictionary.Add(typeof(double?), new LiteralMaker(Literal.MakeDouble)); dictionary.Add(typeof(char?), new LiteralMaker(Literal.MakeChar)); dictionary.Add(typeof(decimal?), new LiteralMaker(Literal.MakeDecimal)); dictionary.Add(typeof(bool?), new LiteralMaker(Literal.MakeBool)); return dictionary; } private static Dictionary CreateTypesDictionary() { // Create the literal class factory delegates Dictionary dictionary = new Dictionary (32); dictionary.Add(typeof(byte), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(byte?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(sbyte), TypeFlags.SignedNumbers); dictionary.Add(typeof(sbyte?), TypeFlags.SignedNumbers); dictionary.Add(typeof(short), TypeFlags.SignedNumbers); dictionary.Add(typeof(short?), TypeFlags.SignedNumbers); dictionary.Add(typeof(int), TypeFlags.SignedNumbers); dictionary.Add(typeof(int?), TypeFlags.SignedNumbers); dictionary.Add(typeof(long), TypeFlags.SignedNumbers); dictionary.Add(typeof(long?), TypeFlags.SignedNumbers); dictionary.Add(typeof(ushort), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(ushort?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(uint), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(uint?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(ulong), TypeFlags.ULong); dictionary.Add(typeof(ulong?), TypeFlags.ULong); dictionary.Add(typeof(float), TypeFlags.Float); dictionary.Add(typeof(float?), TypeFlags.Float); dictionary.Add(typeof(double), TypeFlags.Float); dictionary.Add(typeof(double?), TypeFlags.Float); dictionary.Add(typeof(char), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(char?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(string), TypeFlags.String); dictionary.Add(typeof(decimal), TypeFlags.Decimal); dictionary.Add(typeof(decimal?), TypeFlags.Decimal); dictionary.Add(typeof(bool), TypeFlags.Bool); dictionary.Add(typeof(bool?), TypeFlags.Bool); return dictionary; } #endregion #region Factory Methods internal static Literal MakeLiteral(Type literalType, object literalValue) { if (literalValue == null) return new NullLiteral(literalType); LiteralMaker f; if (types.TryGetValue(literalType, out f)) { try { return f(literalValue); } catch (InvalidCastException e) { throw new RuleEvaluationIncompatibleTypesException( string.Format(CultureInfo.CurrentCulture, Messages.InvalidCast, RuleDecompiler.DecompileType(literalValue.GetType()), RuleDecompiler.DecompileType(literalType)), literalType, CodeBinaryOperatorType.Assign, literalValue.GetType(), e); } } return null; } /// /// Factory function for a boolean type /// /// /// private static Literal MakeBool(object literalValue) { return new BoolLiteral((bool)literalValue); } ////// Factory function for a byte type /// /// /// private static Literal MakeByte(object literalValue) { return new ByteLiteral((byte)literalValue); } ////// Factory function for a sbyte type /// /// /// private static Literal MakeSByte(object literalValue) { return new SByteLiteral((sbyte)literalValue); } ////// Factory function for a char type /// /// /// private static Literal MakeChar(object literalValue) { return new CharLiteral((char)literalValue); } ////// Factory function for a decimal type /// /// /// private static Literal MakeDecimal(object literalValue) { return new DecimalLiteral((decimal)literalValue); } ////// Factory function for an Int16 type /// /// /// private static Literal MakeShort(object literalValue) { return new ShortLiteral((short)literalValue); } ////// Factory function for an Int32 type /// /// /// private static Literal MakeInt(object literalValue) { return new IntLiteral((int)literalValue); } ////// Factory function for an Int64 type /// /// /// private static Literal MakeLong(object literalValue) { return new LongLiteral((long)literalValue); } ////// Factory function for an UInt16 type /// /// /// private static Literal MakeUShort(object literalValue) { return new UShortLiteral((ushort)literalValue); } ////// Factory function for an UInt32 type /// /// /// private static Literal MakeUInt(object literalValue) { return new UIntLiteral((uint)literalValue); } ////// Factory function for an UInt64 type /// /// /// private static Literal MakeULong(object literalValue) { return new ULongLiteral((ulong)literalValue); } ////// Factory function for a float type /// /// /// private static Literal MakeFloat(object literalValue) { return new FloatLiteral((float)literalValue); } ////// Factory function for a double type /// /// /// private static Literal MakeDouble(object literalValue) { return new DoubleLiteral((double)literalValue); } ////// Factory function for a string type /// /// /// private static Literal MakeString(object literalValue) { return new StringLiteral((string)literalValue); } #endregion #region Default Operators internal static class DefaultOperators { public static int Addition(int x, int y) { return x + y; } public static uint Addition(uint x, uint y) { return x + y; } public static long Addition(long x, long y) { return x + y; } public static ulong Addition(ulong x, ulong y) { return x + y; } public static float Addition(float x, float y) { return x + y; } public static double Addition(double x, double y) { return x + y; } public static decimal Addition(decimal x, decimal y) { return x + y; } public static string Addition(string x, string y) { return x + y; } public static string Addition(string x, object y) { return x + y; } public static string Addition(object x, string y) { return x + y; } public static int Subtraction(int x, int y) { return x - y; } public static uint Subtraction(uint x, uint y) { return x - y; } public static long Subtraction(long x, long y) { return x - y; } public static ulong Subtraction(ulong x, ulong y) { return x - y; } public static float Subtraction(float x, float y) { return x - y; } public static double Subtraction(double x, double y) { return x - y; } public static decimal Subtraction(decimal x, decimal y) { return x - y; } public static int Multiply(int x, int y) { return x * y; } public static uint Multiply(uint x, uint y) { return x * y; } public static long Multiply(long x, long y) { return x * y; } public static ulong Multiply(ulong x, ulong y) { return x * y; } public static float Multiply(float x, float y) { return x * y; } public static double Multiply(double x, double y) { return x * y; } public static decimal Multiply(decimal x, decimal y) { return x * y; } public static int Division(int x, int y) { return x / y; } public static uint Division(uint x, uint y) { return x / y; } public static long Division(long x, long y) { return x / y; } public static ulong Division(ulong x, ulong y) { return x / y; } public static float Division(float x, float y) { return x / y; } public static double Division(double x, double y) { return x / y; } public static decimal Division(decimal x, decimal y) { return x / y; } public static int Modulus(int x, int y) { return x % y; } public static uint Modulus(uint x, uint y) { return x % y; } public static long Modulus(long x, long y) { return x % y; } public static ulong Modulus(ulong x, ulong y) { return x % y; } public static float Modulus(float x, float y) { return x % y; } public static double Modulus(double x, double y) { return x % y; } public static decimal Modulus(decimal x, decimal y) { return x % y; } public static int BitwiseAnd(int x, int y) { return x & y; } public static uint BitwiseAnd(uint x, uint y) { return x & y; } public static long BitwiseAnd(long x, long y) { return x & y; } public static ulong BitwiseAnd(ulong x, ulong y) { return x & y; } public static bool BitwiseAnd(bool x, bool y) { return x & y; } public static int BitwiseOr(int x, int y) { return x | y; } public static uint BitwiseOr(uint x, uint y) { return x | y; } public static long BitwiseOr(long x, long y) { return x | y; } public static ulong BitwiseOr(ulong x, ulong y) { return x | y; } public static bool BitwiseOr(bool x, bool y) { return x | y; } public static bool Equality(int x, int y) { return x == y; } public static bool Equality(uint x, uint y) { return x == y; } public static bool Equality(long x, long y) { return x == y; } public static bool Equality(ulong x, ulong y) { return x == y; } public static bool Equality(float x, float y) { return x == y; } public static bool Equality(double x, double y) { return x == y; } public static bool Equality(decimal x, decimal y) { return x == y; } public static bool Equality(bool x, bool y) { return x == y; } public static bool Equality(string x, string y) { return x == y; } // mark object == object since it has special rules public static bool ObjectEquality(object x, object y) { return x == y; } public static bool GreaterThan(int x, int y) { return x > y; } public static bool GreaterThan(uint x, uint y) { return x > y; } public static bool GreaterThan(long x, long y) { return x > y; } public static bool GreaterThan(ulong x, ulong y) { return x > y; } public static bool GreaterThan(float x, float y) { return x > y; } public static bool GreaterThan(double x, double y) { return x > y; } public static bool GreaterThan(decimal x, decimal y) { return x > y; } public static bool GreaterThanOrEqual(int x, int y) { return x >= y; } public static bool GreaterThanOrEqual(uint x, uint y) { return x >= y; } public static bool GreaterThanOrEqual(long x, long y) { return x >= y; } public static bool GreaterThanOrEqual(ulong x, ulong y) { return x >= y; } public static bool GreaterThanOrEqual(float x, float y) { return x >= y; } public static bool GreaterThanOrEqual(double x, double y) { return x >= y; } public static bool GreaterThanOrEqual(decimal x, decimal y) { return x >= y; } public static bool LessThan(int x, int y) { return x < y; } public static bool LessThan(uint x, uint y) { return x < y; } public static bool LessThan(long x, long y) { return x < y; } public static bool LessThan(ulong x, ulong y) { return x < y; } public static bool LessThan(float x, float y) { return x < y; } public static bool LessThan(double x, double y) { return x < y; } public static bool LessThan(decimal x, decimal y) { return x < y; } public static bool LessThanOrEqual(int x, int y) { return x <= y; } public static bool LessThanOrEqual(uint x, uint y) { return x <= y; } public static bool LessThanOrEqual(long x, long y) { return x <= y; } public static bool LessThanOrEqual(ulong x, ulong y) { return x <= y; } public static bool LessThanOrEqual(float x, float y) { return x <= y; } public static bool LessThanOrEqual(double x, double y) { return x <= y; } public static bool LessThanOrEqual(decimal x, decimal y) { return x <= y; } } #endregion #region Type Checking Methods [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] internal static RuleBinaryExpressionInfo AllowedComparison( Type lhs, CodeExpression lhsExpression, Type rhs, CodeExpression rhsExpression, CodeBinaryOperatorType comparison, RuleValidation validator, out ValidationError error) { // note that null values come in as a NullLiteral type TypeFlags lhsFlags, rhsFlags; // are the types supported? if ((supportedTypes.TryGetValue(lhs, out lhsFlags)) && (supportedTypes.TryGetValue(rhs, out rhsFlags))) { // both sides supported if (lhsFlags == rhsFlags) { // both sides the same type, so it's allowed // only allow equality on booleans if ((lhsFlags == TypeFlags.Bool) && (comparison != CodeBinaryOperatorType.ValueEquality)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), RuleDecompiler.DecompileType(lhs), RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } error = null; return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); } // if not the same, only certain combinations allowed switch (lhsFlags | rhsFlags) { case TypeFlags.Decimal | TypeFlags.SignedNumbers: case TypeFlags.Decimal | TypeFlags.UnsignedNumbers: case TypeFlags.Decimal | TypeFlags.ULong: case TypeFlags.Float | TypeFlags.SignedNumbers: case TypeFlags.Float | TypeFlags.UnsignedNumbers: case TypeFlags.Float | TypeFlags.ULong: case TypeFlags.ULong | TypeFlags.UnsignedNumbers: case TypeFlags.SignedNumbers | TypeFlags.UnsignedNumbers: error = null; return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); } string message2 = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message2, ErrorNumbers.Error_OperandTypesIncompatible); return null; } else { // see if they override the operator MethodInfo operatorOverride = MapOperatorToMethod(comparison, lhs, lhsExpression, rhs, rhsExpression, validator, out error); if (operatorOverride != null) return new RuleBinaryExpressionInfo(lhs, rhs, operatorOverride); // unable to evaluate, so return false return null; } } internal enum OperatorGrouping { Arithmetic, Equality, Relational } internal static MethodInfo ObjectEquality = typeof(DefaultOperators).GetMethod("ObjectEquality"); [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] // bogus since the casts are in different case statements internal static MethodInfo MapOperatorToMethod( CodeBinaryOperatorType op, Type lhs, CodeExpression lhsExpression, Type rhs, CodeExpression rhsExpression, RuleValidation validator, out ValidationError error) { // determine what the method name should be string methodName; string message; OperatorGrouping group; switch (op) { case CodeBinaryOperatorType.ValueEquality: methodName = "op_Equality"; group = OperatorGrouping.Equality; break; case CodeBinaryOperatorType.GreaterThan: methodName = "op_GreaterThan"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.GreaterThanOrEqual: methodName = "op_GreaterThanOrEqual"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.LessThan: methodName = "op_LessThan"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.LessThanOrEqual: methodName = "op_LessThanOrEqual"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.Add: methodName = "op_Addition"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Subtract: methodName = "op_Subtraction"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Multiply: methodName = "op_Multiply"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Divide: methodName = "op_Division"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Modulus: methodName = "op_Modulus"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.BitwiseAnd: methodName = "op_BitwiseAnd"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.BitwiseOr: methodName = "op_BitwiseOr"; group = OperatorGrouping.Arithmetic; break; default: Debug.Assert(false, "Operator " + op.ToString() + " not implemented"); message = string.Format(CultureInfo.CurrentCulture, Messages.BinaryOpNotSupported, op.ToString()); error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled); return null; } // NOTE: types maybe NullLiteral, which signifies the constant "null" Listcandidates = new List (); bool lhsNullable = ConditionHelper.IsNullableValueType(lhs); bool rhsNullable = ConditionHelper.IsNullableValueType(rhs); Type lhsType0 = (lhsNullable) ? Nullable.GetUnderlyingType(lhs) : lhs; Type rhsType0 = (rhsNullable) ? Nullable.GetUnderlyingType(rhs) : rhs; // special cases for enums if (lhsType0.IsEnum) { // only 3 cases (U = underlying type of E): // E = E + U // U = E - E // E = E - U // plus the standard comparisons (E == E, E > E, etc.) // need to also allow E == 0 Type underlyingType; switch (op) { case CodeBinaryOperatorType.Add: underlyingType = EnumHelper.GetUnderlyingType(lhsType0); if ((underlyingType != null) && (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error))) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } break; case CodeBinaryOperatorType.Subtract: underlyingType = EnumHelper.GetUnderlyingType(lhsType0); if (underlyingType != null) { if (lhsType0 == rhsType0) { // E - E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression)) { // E - 0, can convert 0 to E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } else if (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)) { // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } } break; case CodeBinaryOperatorType.ValueEquality: case CodeBinaryOperatorType.LessThan: case CodeBinaryOperatorType.LessThanOrEqual: case CodeBinaryOperatorType.GreaterThan: case CodeBinaryOperatorType.GreaterThanOrEqual: if (lhsType0 == rhsType0) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } else if (lhsNullable && (rhs == typeof(NullLiteral))) { // handle enum? op null // treat the rhs as the same nullable enum error = null; return new EnumOperationMethodInfo(lhs, op, lhs, false); } else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression)) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } break; } // can't do it, sorry // but check if there is a user-defined operator that works } else if (rhsType0.IsEnum) { // lhs != enum, so only 2 cases (U = underlying type of E): // E = U + E // E = U - E // comparisons are E == E, etc., so if the lhs is not an enum, too bad // although we need to check for 0 == E Type underlyingType; switch (op) { case CodeBinaryOperatorType.Add: underlyingType = EnumHelper.GetUnderlyingType(rhsType0); if ((underlyingType != null) && (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error))) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } break; case CodeBinaryOperatorType.Subtract: underlyingType = EnumHelper.GetUnderlyingType(rhsType0); if (underlyingType != null) { CodePrimitiveExpression primitive = lhsExpression as CodePrimitiveExpression; if (DecimalIntegerLiteralZero(lhs, primitive)) { // 0 - E, can convert 0 to E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } else if (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error)) { // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } } break; case CodeBinaryOperatorType.ValueEquality: case CodeBinaryOperatorType.LessThan: case CodeBinaryOperatorType.LessThanOrEqual: case CodeBinaryOperatorType.GreaterThan: case CodeBinaryOperatorType.GreaterThanOrEqual: if (rhsNullable && (lhs == typeof(NullLiteral))) { // handle null op enum? // treat the lhs as the same nullable enum type error = null; return new EnumOperationMethodInfo(rhs, op, rhs, false); } else if (DecimalIntegerLiteralZero(lhs, lhsExpression as CodePrimitiveExpression)) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } break; } // can't do it, sorry // but check if there is a user-defined operator that works } // enum specific operations already handled, see if one side (or both) define operators AddOperatorOverloads(lhsType0, methodName, lhs, rhs, candidates); AddOperatorOverloads(rhsType0, methodName, lhs, rhs, candidates); if (lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral))) { // need to add in lifted methods AddLiftedOperators(lhsType0, methodName, group, lhsType0, rhsType0, candidates); AddLiftedOperators(rhsType0, methodName, group, lhsType0, rhsType0, candidates); } if (candidates.Count == 0) { // no overrides, so get the default list methodName = methodName.Substring(3); // strip off the op_ foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) { if (mi.Name == methodName) { ParameterInfo[] parameters = mi.GetParameters(); Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; if (RuleValidation.ImplicitConversion(lhs, parm1) && RuleValidation.ImplicitConversion(rhs, parm2)) { candidates.Add(mi); } } } // if no candidates and ==, can we use object == object? if ((candidates.Count == 0) && ("Equality" == methodName)) { // C# 7.9.6 // references must be compatible // no boxing // value types can't be compared if ((!lhs.IsValueType) && (!rhs.IsValueType)) { // they are not classes, so references need to be compatible // also check for null (which is NullLiteral type) -- null is compatible with any object type if ((lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)) || (lhs.IsAssignableFrom(rhs)) || (rhs.IsAssignableFrom(lhs))) { candidates.Add(ObjectEquality); } } } // if no candidates and nullable, add lifted operators if ((candidates.Count == 0) && ((lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral))))) { foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) { if (mi.Name == methodName) { ParameterInfo[] parameters = mi.GetParameters(); MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, lhsType0, rhsType0); if (liftedMethod != null) candidates.Add(liftedMethod); } } } } if (candidates.Count == 1) { // only 1, so it is it error = null; return candidates[0]; } else if (candidates.Count == 0) { // nothing matched message = string.Format(CultureInfo.CurrentCulture, (group == OperatorGrouping.Arithmetic) ? Messages.ArithOpBadTypes : Messages.RelationalOpBadTypes, op.ToString(), (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } else { // more than 1, so pick the best one MethodInfo bestFit = validator.FindBestCandidate(null, candidates, lhs, rhs); if (bestFit != null) { error = null; return bestFit; } // must be ambiguous. Since there are at least 2 choices, show only the first 2 message = string.Format(CultureInfo.CurrentCulture, Messages.AmbiguousOperator, op.ToString(), RuleDecompiler.DecompileMethod(candidates[0]), RuleDecompiler.DecompileMethod(candidates[1])); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } } private static bool DecimalIntegerLiteralZero(Type type, CodePrimitiveExpression expression) { if (expression != null) { if (type == typeof(int)) return expression.Value.Equals(0); else if (type == typeof(uint)) return expression.Value.Equals(0U); else if (type == typeof(long)) return expression.Value.Equals(0L); else if (type == typeof(ulong)) return expression.Value.Equals(0UL); } return false; } private static void AddOperatorOverloads(Type type, string methodName, Type arg1, Type arg2, List candidates) { // append the list of methods that match the name specified int numAdded = 0; MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { if (EvaluateMethod(parameters, arg1, arg2)) { ++numAdded; if (!candidates.Contains(mi)) candidates.Add(mi); } } } if ((numAdded > 0) || (type == typeof(object))) return; // no matches, check direct base class (if there is one) type = type.BaseType; if (type != null) { possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { if (EvaluateMethod(parameters, arg1, arg2)) { if (!candidates.Contains(mi)) candidates.Add(mi); } } } } } private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List candidates) { // append the list of lifted methods that match the name specified int numAdded = 0; MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); if (liftedMethod != null) { ++numAdded; if (!candidates.Contains(liftedMethod)) candidates.Add(liftedMethod); } } } if ((numAdded > 0) || (type == typeof(object))) return; // no matches, check direct base class (if there is one) type = type.BaseType; if (type != null) { possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); if ((liftedMethod != null) && !candidates.Contains(liftedMethod)) candidates.Add(liftedMethod); } } } } private static bool EvaluateMethod(ParameterInfo[] parameters, Type arg1, Type arg2) { Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; return (RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)); } private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2) { Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; if (ConditionHelper.IsNonNullableValueType(parm1) && ConditionHelper.IsNonNullableValueType(parm2)) { // lift the parameters for testing conversions, if possible parm1 = typeof(Nullable<>).MakeGenericType(parm1); parm2 = typeof(Nullable<>).MakeGenericType(parm2); switch (group) { case OperatorGrouping.Equality: // for == != if (mi.ReturnType == typeof(bool) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedEqualityOperatorMethodInfo(mi); } break; case OperatorGrouping.Relational: // for < > <= >= if (mi.ReturnType == typeof(bool) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedRelationalOperatorMethodInfo(mi); } break; case OperatorGrouping.Arithmetic: // for + - * / % & ^ if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedArithmeticOperatorMethodInfo(mi); } break; } } return null; } #endregion #region Value Type Dispatch Methods /// /// Relational equal operator /// Value-equality if we can do it, otherwise reference-equality /// /// ///internal abstract bool Equal(Literal rhs); internal virtual bool Equal(byte literalValue) { return false; } internal virtual bool Equal(sbyte literalValue) { return false; } internal virtual bool Equal(short literalValue) { return false; } internal virtual bool Equal(int literalValue) { return false; } internal virtual bool Equal(long literalValue) { return false; } internal virtual bool Equal(ushort literalValue) { return false; } internal virtual bool Equal(uint literalValue) { return false; } internal virtual bool Equal(ulong literalValue) { return false; } internal virtual bool Equal(float literalValue) { return false; } internal virtual bool Equal(double literalValue) { return false; } internal virtual bool Equal(char literalValue) { return false; } internal virtual bool Equal(string literalValue) { return false; } internal virtual bool Equal(decimal literalValue) { return false; } internal virtual bool Equal(bool literalValue) { return false; } /// /// Relational less than operator /// /// ///internal abstract bool LessThan(Literal rhs); internal virtual bool LessThan() { return false; } internal virtual bool LessThan(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } /// /// Relational greater than operator /// /// ///internal abstract bool GreaterThan(Literal rhs); internal virtual bool GreaterThan() { return false; } internal virtual bool GreaterThan(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } /// /// Relational less than or equal to operator /// /// ///internal abstract bool LessThanOrEqual(Literal rhs); internal virtual bool LessThanOrEqual() { return false; } internal virtual bool LessThanOrEqual(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } /// /// Relational greater than or equal to operator /// /// ///internal abstract bool GreaterThanOrEqual(Literal rhs); internal virtual bool GreaterThanOrEqual() { return false; } internal virtual bool GreaterThanOrEqual(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } #endregion } #endregion #region Null Literal Class /// /// Represents an null literal /// internal class NullLiteral : Literal { // NOTE (from MSDN page on IComparable.CompareTo Method): // By definition, any object compares greater than a null reference // But C# (24.3.1) doesn't -- if either side is null, result is false internal NullLiteral(Type type) { m_type = type; } internal override object Value { get { return null; } } internal override bool Equal(Literal rhs) { return rhs.Value == null; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(); } internal override bool LessThan(byte literalValue) { return false; } internal override bool LessThan(char literalValue) { return false; } internal override bool LessThan(sbyte literalValue) { return false; } internal override bool LessThan(short literalValue) { return false; } internal override bool LessThan(int literalValue) { return false; } internal override bool LessThan(long literalValue) { return false; } internal override bool LessThan(ushort literalValue) { return false; } internal override bool LessThan(uint literalValue) { return false; } internal override bool LessThan(ulong literalValue) { return false; } internal override bool LessThan(float literalValue) { return false; } internal override bool LessThan(double literalValue) { return false; } internal override bool LessThan(string literalValue) { // for strings, maintain compatibility with v1 return true; } internal override bool LessThan(decimal literalValue) { return false; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(); } internal override bool GreaterThan(byte literalValue) { return false; } internal override bool GreaterThan(char literalValue) { return false; } internal override bool GreaterThan(sbyte literalValue) { return false; } internal override bool GreaterThan(short literalValue) { return false; } internal override bool GreaterThan(int literalValue) { return false; } internal override bool GreaterThan(long literalValue) { return false; } internal override bool GreaterThan(ushort literalValue) { return false; } internal override bool GreaterThan(uint literalValue) { return false; } internal override bool GreaterThan(ulong literalValue) { return false; } internal override bool GreaterThan(float literalValue) { return false; } internal override bool GreaterThan(double literalValue) { return false; } internal override bool GreaterThan(string literalValue) { return false; } internal override bool GreaterThan(decimal literalValue) { return false; } ////// Relational less than or equal to operator /// /// ///internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(); } internal override bool LessThanOrEqual() { return (m_type == typeof(string)); // null == null for strings only } internal override bool LessThanOrEqual(byte literalValue) { return false; } internal override bool LessThanOrEqual(char literalValue) { return false; } internal override bool LessThanOrEqual(sbyte literalValue) { return false; } internal override bool LessThanOrEqual(short literalValue) { return false; } internal override bool LessThanOrEqual(int literalValue) { return false; } internal override bool LessThanOrEqual(long literalValue) { return false; } internal override bool LessThanOrEqual(ushort literalValue) { return false; } internal override bool LessThanOrEqual(uint literalValue) { return false; } internal override bool LessThanOrEqual(ulong literalValue) { return false; } internal override bool LessThanOrEqual(float literalValue) { return false; } internal override bool LessThanOrEqual(double literalValue) { return false; } internal override bool LessThanOrEqual(string literalValue) { // for strings, maintain compatibility with v1 return true; } internal override bool LessThanOrEqual(decimal literalValue) { return false; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(); } internal override bool GreaterThanOrEqual() { return (m_type == typeof(string)); // null == null for strings only } internal override bool GreaterThanOrEqual(byte literalValue) { return false; } internal override bool GreaterThanOrEqual(char literalValue) { return false; } internal override bool GreaterThanOrEqual(sbyte literalValue) { return false; } internal override bool GreaterThanOrEqual(short literalValue) { return false; } internal override bool GreaterThanOrEqual(int literalValue) { return false; } internal override bool GreaterThanOrEqual(long literalValue) { return false; } internal override bool GreaterThanOrEqual(ushort literalValue) { return false; } internal override bool GreaterThanOrEqual(uint literalValue) { return false; } internal override bool GreaterThanOrEqual(ulong literalValue) { return false; } internal override bool GreaterThanOrEqual(float literalValue) { return false; } internal override bool GreaterThanOrEqual(double literalValue) { return false; } internal override bool GreaterThanOrEqual(string literalValue) { return false; } internal override bool GreaterThanOrEqual(decimal literalValue) { return false; } } #endregion #region Boolean Literal Class /// /// Represents a boolean literal /// internal class BoolLiteral : Literal { private bool m_value; internal override object Value { get { return m_value; } } internal BoolLiteral(bool literalValue) { m_value = literalValue; m_type = typeof(bool); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(bool rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } } #endregion #region Byte Literal Class ////// Represents a byte literal /// internal class ByteLiteral : Literal { private byte m_value; internal override object Value { get { return m_value; } } internal ByteLiteral(byte literalValue) { m_value = literalValue; m_type = typeof(byte); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region SByte Literal Class ////// Represents a byte literal /// internal class SByteLiteral : Literal { private sbyte m_value; internal override object Value { get { return m_value; } } internal SByteLiteral(sbyte literalValue) { m_value = literalValue; m_type = typeof(sbyte); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Char Literal Class ////// Represents a byte literal /// internal class CharLiteral : Literal { private char m_value; internal override object Value { get { return m_value; } } internal CharLiteral(char literalValue) { m_value = literalValue; m_type = typeof(char); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Decimal Literal Class ////// Represents a decimal literal /// internal class DecimalLiteral : Literal { private decimal m_value; internal override object Value { get { return m_value; } } internal DecimalLiteral(decimal literalValue) { m_value = literalValue; m_type = typeof(decimal); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int16 Literal Class ////// Represents an Int16 literal /// internal class ShortLiteral : Literal { private short m_value; internal override object Value { get { return m_value; } } internal ShortLiteral(short literalValue) { m_value = literalValue; m_type = typeof(short); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int32 Literal Class ////// Represents an Int32 literal /// internal class IntLiteral : Literal { private int m_value; internal override object Value { get { return m_value; } } internal IntLiteral(int literalValue) { m_value = literalValue; m_type = typeof(int); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return (m_value < 0) || ((ulong)m_value < rhs); } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return (m_value >= 0) && ((ulong)m_value > rhs); } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return (m_value < 0) || ((ulong)m_value <= rhs); } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return (m_value >= 0) && ((ulong)m_value >= rhs); } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int64 Literal Class ////// Represents an Int64 literal /// internal class LongLiteral : Literal { private long m_value; internal override object Value { get { return m_value; } } internal LongLiteral(long literalValue) { m_value = literalValue; m_type = typeof(long); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return (m_value < 0) || ((ulong)m_value < rhs); } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return (m_value >= 0) && ((ulong)m_value > rhs); } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return (m_value < 0) || ((ulong)m_value <= rhs); } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return (m_value >= 0) && ((ulong)m_value >= rhs); } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt16 Literal Class ////// Represents an UInt16 literal /// internal class UShortLiteral : Literal { private ushort m_value; internal override object Value { get { return m_value; } } internal UShortLiteral(ushort literalValue) { m_value = literalValue; m_type = typeof(ushort); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt32 Literal Class ////// Represents an UInt32 literal /// internal class UIntLiteral : Literal { private uint m_value; internal override object Value { get { return m_value; } } internal UIntLiteral(uint literalValue) { m_value = literalValue; m_type = typeof(uint); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt64 Literal Class ////// Represents an UInt64 literal /// internal class ULongLiteral : Literal { private ulong m_value; internal override object Value { get { return m_value; } } internal ULongLiteral(ulong literalValue) { m_value = literalValue; m_type = typeof(ulong); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(sbyte rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(short rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(int rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(long rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return (rhs >= 0) && (m_value < (ulong)rhs); } internal override bool LessThan(long rhs) { return (rhs >= 0) && (m_value < (ulong)rhs); } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return (rhs < 0) || (m_value > (ulong)rhs); } internal override bool GreaterThan(long rhs) { return (rhs < 0) || (m_value > (ulong)rhs); } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return (rhs >= 0) && (m_value <= (ulong)rhs); } internal override bool LessThanOrEqual(long rhs) { return (rhs >= 0) && (m_value <= (ulong)rhs); } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return (rhs < 0) || (m_value >= (ulong)rhs); } internal override bool GreaterThanOrEqual(long rhs) { return (rhs < 0) || (m_value >= (ulong)rhs); } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Double Literal Class ////// Represents a double literal /// internal class DoubleLiteral : Literal { private double m_value; internal override object Value { get { return m_value; } } internal DoubleLiteral(double literalValue) { m_value = literalValue; m_type = typeof(double); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } } #endregion #region Float Literal Class ////// Represents a float literal /// internal class FloatLiteral : Literal { private float m_value; internal override object Value { get { return m_value; } } internal FloatLiteral(float literalValue) { m_value = literalValue; m_type = typeof(float); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } } #endregion #region String Literal Class ////// Represents a string literal /// internal class StringLiteral : Literal { private string m_value; internal override object Value { get { return m_value; } } internal StringLiteral(string internalValue) { m_value = internalValue; m_type = typeof(string); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(string rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(string rhs) { return 0 > string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan() { return true; } internal override bool GreaterThan(string rhs) { return 0 < string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(string rhs) { return 0 >= string.Compare(m_value, (string)rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual() { return true; } internal override bool GreaterThanOrEqual(string rhs) { return 0 <= string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } } #endregion } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved. // ---------------------------------------------------------------------------- // Copyright (C) 2005 Microsoft Corporation All Rights Reserved // --------------------------------------------------------------------------- #define CODE_ANALYSIS using System.CodeDom; using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Reflection; using System.Workflow.ComponentModel; using System.Workflow.ComponentModel.Compiler; using System.Workflow.Activities.Common; namespace System.Workflow.Activities.Rules { #region Literal Class ////// Represents a typed literal value and is the base class for all type specific literal classes /// internal abstract class Literal { #region Properties ////// A delegate for literal factory methods /// private delegate Literal LiteralMaker(object literalValue); ////// Collection of literal factory methods indexed by type /// static private Dictionarytypes = CreateMakersDictionary(); /// /// The type of the literal /// protected internal Type m_type; ////// Get the boxed literal /// internal abstract object Value { get; } ////// Group types by similar characteristics so we can check if comparisons succeed /// [Flags()] enum TypeFlags { SignedNumbers = 0x01, UnsignedNumbers = 0x02, ULong = 0x04, Float = 0x08, Decimal = 0x10, String = 0x20, Bool = 0x40 }; ////// Collection of TypeFlags for the supported value types indexed by type /// private static DictionarysupportedTypes = CreateTypesDictionary(); private static Dictionary CreateMakersDictionary() { // Create the literal class factory delegates Dictionary dictionary = new Dictionary (32); dictionary.Add(typeof(byte), new LiteralMaker(Literal.MakeByte)); dictionary.Add(typeof(sbyte), new LiteralMaker(Literal.MakeSByte)); dictionary.Add(typeof(short), new LiteralMaker(Literal.MakeShort)); dictionary.Add(typeof(int), new LiteralMaker(Literal.MakeInt)); dictionary.Add(typeof(long), new LiteralMaker(Literal.MakeLong)); dictionary.Add(typeof(ushort), new LiteralMaker(Literal.MakeUShort)); dictionary.Add(typeof(uint), new LiteralMaker(Literal.MakeUInt)); dictionary.Add(typeof(ulong), new LiteralMaker(Literal.MakeULong)); dictionary.Add(typeof(float), new LiteralMaker(Literal.MakeFloat)); dictionary.Add(typeof(double), new LiteralMaker(Literal.MakeDouble)); dictionary.Add(typeof(char), new LiteralMaker(Literal.MakeChar)); dictionary.Add(typeof(string), new LiteralMaker(Literal.MakeString)); dictionary.Add(typeof(decimal), new LiteralMaker(Literal.MakeDecimal)); dictionary.Add(typeof(bool), new LiteralMaker(Literal.MakeBool)); dictionary.Add(typeof(byte?), new LiteralMaker(Literal.MakeByte)); dictionary.Add(typeof(sbyte?), new LiteralMaker(Literal.MakeSByte)); dictionary.Add(typeof(short?), new LiteralMaker(Literal.MakeShort)); dictionary.Add(typeof(int?), new LiteralMaker(Literal.MakeInt)); dictionary.Add(typeof(long?), new LiteralMaker(Literal.MakeLong)); dictionary.Add(typeof(ushort?), new LiteralMaker(Literal.MakeUShort)); dictionary.Add(typeof(uint?), new LiteralMaker(Literal.MakeUInt)); dictionary.Add(typeof(ulong?), new LiteralMaker(Literal.MakeULong)); dictionary.Add(typeof(float?), new LiteralMaker(Literal.MakeFloat)); dictionary.Add(typeof(double?), new LiteralMaker(Literal.MakeDouble)); dictionary.Add(typeof(char?), new LiteralMaker(Literal.MakeChar)); dictionary.Add(typeof(decimal?), new LiteralMaker(Literal.MakeDecimal)); dictionary.Add(typeof(bool?), new LiteralMaker(Literal.MakeBool)); return dictionary; } private static Dictionary CreateTypesDictionary() { // Create the literal class factory delegates Dictionary dictionary = new Dictionary (32); dictionary.Add(typeof(byte), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(byte?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(sbyte), TypeFlags.SignedNumbers); dictionary.Add(typeof(sbyte?), TypeFlags.SignedNumbers); dictionary.Add(typeof(short), TypeFlags.SignedNumbers); dictionary.Add(typeof(short?), TypeFlags.SignedNumbers); dictionary.Add(typeof(int), TypeFlags.SignedNumbers); dictionary.Add(typeof(int?), TypeFlags.SignedNumbers); dictionary.Add(typeof(long), TypeFlags.SignedNumbers); dictionary.Add(typeof(long?), TypeFlags.SignedNumbers); dictionary.Add(typeof(ushort), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(ushort?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(uint), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(uint?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(ulong), TypeFlags.ULong); dictionary.Add(typeof(ulong?), TypeFlags.ULong); dictionary.Add(typeof(float), TypeFlags.Float); dictionary.Add(typeof(float?), TypeFlags.Float); dictionary.Add(typeof(double), TypeFlags.Float); dictionary.Add(typeof(double?), TypeFlags.Float); dictionary.Add(typeof(char), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(char?), TypeFlags.UnsignedNumbers); dictionary.Add(typeof(string), TypeFlags.String); dictionary.Add(typeof(decimal), TypeFlags.Decimal); dictionary.Add(typeof(decimal?), TypeFlags.Decimal); dictionary.Add(typeof(bool), TypeFlags.Bool); dictionary.Add(typeof(bool?), TypeFlags.Bool); return dictionary; } #endregion #region Factory Methods internal static Literal MakeLiteral(Type literalType, object literalValue) { if (literalValue == null) return new NullLiteral(literalType); LiteralMaker f; if (types.TryGetValue(literalType, out f)) { try { return f(literalValue); } catch (InvalidCastException e) { throw new RuleEvaluationIncompatibleTypesException( string.Format(CultureInfo.CurrentCulture, Messages.InvalidCast, RuleDecompiler.DecompileType(literalValue.GetType()), RuleDecompiler.DecompileType(literalType)), literalType, CodeBinaryOperatorType.Assign, literalValue.GetType(), e); } } return null; } /// /// Factory function for a boolean type /// /// /// private static Literal MakeBool(object literalValue) { return new BoolLiteral((bool)literalValue); } ////// Factory function for a byte type /// /// /// private static Literal MakeByte(object literalValue) { return new ByteLiteral((byte)literalValue); } ////// Factory function for a sbyte type /// /// /// private static Literal MakeSByte(object literalValue) { return new SByteLiteral((sbyte)literalValue); } ////// Factory function for a char type /// /// /// private static Literal MakeChar(object literalValue) { return new CharLiteral((char)literalValue); } ////// Factory function for a decimal type /// /// /// private static Literal MakeDecimal(object literalValue) { return new DecimalLiteral((decimal)literalValue); } ////// Factory function for an Int16 type /// /// /// private static Literal MakeShort(object literalValue) { return new ShortLiteral((short)literalValue); } ////// Factory function for an Int32 type /// /// /// private static Literal MakeInt(object literalValue) { return new IntLiteral((int)literalValue); } ////// Factory function for an Int64 type /// /// /// private static Literal MakeLong(object literalValue) { return new LongLiteral((long)literalValue); } ////// Factory function for an UInt16 type /// /// /// private static Literal MakeUShort(object literalValue) { return new UShortLiteral((ushort)literalValue); } ////// Factory function for an UInt32 type /// /// /// private static Literal MakeUInt(object literalValue) { return new UIntLiteral((uint)literalValue); } ////// Factory function for an UInt64 type /// /// /// private static Literal MakeULong(object literalValue) { return new ULongLiteral((ulong)literalValue); } ////// Factory function for a float type /// /// /// private static Literal MakeFloat(object literalValue) { return new FloatLiteral((float)literalValue); } ////// Factory function for a double type /// /// /// private static Literal MakeDouble(object literalValue) { return new DoubleLiteral((double)literalValue); } ////// Factory function for a string type /// /// /// private static Literal MakeString(object literalValue) { return new StringLiteral((string)literalValue); } #endregion #region Default Operators internal static class DefaultOperators { public static int Addition(int x, int y) { return x + y; } public static uint Addition(uint x, uint y) { return x + y; } public static long Addition(long x, long y) { return x + y; } public static ulong Addition(ulong x, ulong y) { return x + y; } public static float Addition(float x, float y) { return x + y; } public static double Addition(double x, double y) { return x + y; } public static decimal Addition(decimal x, decimal y) { return x + y; } public static string Addition(string x, string y) { return x + y; } public static string Addition(string x, object y) { return x + y; } public static string Addition(object x, string y) { return x + y; } public static int Subtraction(int x, int y) { return x - y; } public static uint Subtraction(uint x, uint y) { return x - y; } public static long Subtraction(long x, long y) { return x - y; } public static ulong Subtraction(ulong x, ulong y) { return x - y; } public static float Subtraction(float x, float y) { return x - y; } public static double Subtraction(double x, double y) { return x - y; } public static decimal Subtraction(decimal x, decimal y) { return x - y; } public static int Multiply(int x, int y) { return x * y; } public static uint Multiply(uint x, uint y) { return x * y; } public static long Multiply(long x, long y) { return x * y; } public static ulong Multiply(ulong x, ulong y) { return x * y; } public static float Multiply(float x, float y) { return x * y; } public static double Multiply(double x, double y) { return x * y; } public static decimal Multiply(decimal x, decimal y) { return x * y; } public static int Division(int x, int y) { return x / y; } public static uint Division(uint x, uint y) { return x / y; } public static long Division(long x, long y) { return x / y; } public static ulong Division(ulong x, ulong y) { return x / y; } public static float Division(float x, float y) { return x / y; } public static double Division(double x, double y) { return x / y; } public static decimal Division(decimal x, decimal y) { return x / y; } public static int Modulus(int x, int y) { return x % y; } public static uint Modulus(uint x, uint y) { return x % y; } public static long Modulus(long x, long y) { return x % y; } public static ulong Modulus(ulong x, ulong y) { return x % y; } public static float Modulus(float x, float y) { return x % y; } public static double Modulus(double x, double y) { return x % y; } public static decimal Modulus(decimal x, decimal y) { return x % y; } public static int BitwiseAnd(int x, int y) { return x & y; } public static uint BitwiseAnd(uint x, uint y) { return x & y; } public static long BitwiseAnd(long x, long y) { return x & y; } public static ulong BitwiseAnd(ulong x, ulong y) { return x & y; } public static bool BitwiseAnd(bool x, bool y) { return x & y; } public static int BitwiseOr(int x, int y) { return x | y; } public static uint BitwiseOr(uint x, uint y) { return x | y; } public static long BitwiseOr(long x, long y) { return x | y; } public static ulong BitwiseOr(ulong x, ulong y) { return x | y; } public static bool BitwiseOr(bool x, bool y) { return x | y; } public static bool Equality(int x, int y) { return x == y; } public static bool Equality(uint x, uint y) { return x == y; } public static bool Equality(long x, long y) { return x == y; } public static bool Equality(ulong x, ulong y) { return x == y; } public static bool Equality(float x, float y) { return x == y; } public static bool Equality(double x, double y) { return x == y; } public static bool Equality(decimal x, decimal y) { return x == y; } public static bool Equality(bool x, bool y) { return x == y; } public static bool Equality(string x, string y) { return x == y; } // mark object == object since it has special rules public static bool ObjectEquality(object x, object y) { return x == y; } public static bool GreaterThan(int x, int y) { return x > y; } public static bool GreaterThan(uint x, uint y) { return x > y; } public static bool GreaterThan(long x, long y) { return x > y; } public static bool GreaterThan(ulong x, ulong y) { return x > y; } public static bool GreaterThan(float x, float y) { return x > y; } public static bool GreaterThan(double x, double y) { return x > y; } public static bool GreaterThan(decimal x, decimal y) { return x > y; } public static bool GreaterThanOrEqual(int x, int y) { return x >= y; } public static bool GreaterThanOrEqual(uint x, uint y) { return x >= y; } public static bool GreaterThanOrEqual(long x, long y) { return x >= y; } public static bool GreaterThanOrEqual(ulong x, ulong y) { return x >= y; } public static bool GreaterThanOrEqual(float x, float y) { return x >= y; } public static bool GreaterThanOrEqual(double x, double y) { return x >= y; } public static bool GreaterThanOrEqual(decimal x, decimal y) { return x >= y; } public static bool LessThan(int x, int y) { return x < y; } public static bool LessThan(uint x, uint y) { return x < y; } public static bool LessThan(long x, long y) { return x < y; } public static bool LessThan(ulong x, ulong y) { return x < y; } public static bool LessThan(float x, float y) { return x < y; } public static bool LessThan(double x, double y) { return x < y; } public static bool LessThan(decimal x, decimal y) { return x < y; } public static bool LessThanOrEqual(int x, int y) { return x <= y; } public static bool LessThanOrEqual(uint x, uint y) { return x <= y; } public static bool LessThanOrEqual(long x, long y) { return x <= y; } public static bool LessThanOrEqual(ulong x, ulong y) { return x <= y; } public static bool LessThanOrEqual(float x, float y) { return x <= y; } public static bool LessThanOrEqual(double x, double y) { return x <= y; } public static bool LessThanOrEqual(decimal x, decimal y) { return x <= y; } } #endregion #region Type Checking Methods [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] internal static RuleBinaryExpressionInfo AllowedComparison( Type lhs, CodeExpression lhsExpression, Type rhs, CodeExpression rhsExpression, CodeBinaryOperatorType comparison, RuleValidation validator, out ValidationError error) { // note that null values come in as a NullLiteral type TypeFlags lhsFlags, rhsFlags; // are the types supported? if ((supportedTypes.TryGetValue(lhs, out lhsFlags)) && (supportedTypes.TryGetValue(rhs, out rhsFlags))) { // both sides supported if (lhsFlags == rhsFlags) { // both sides the same type, so it's allowed // only allow equality on booleans if ((lhsFlags == TypeFlags.Bool) && (comparison != CodeBinaryOperatorType.ValueEquality)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), RuleDecompiler.DecompileType(lhs), RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } error = null; return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); } // if not the same, only certain combinations allowed switch (lhsFlags | rhsFlags) { case TypeFlags.Decimal | TypeFlags.SignedNumbers: case TypeFlags.Decimal | TypeFlags.UnsignedNumbers: case TypeFlags.Decimal | TypeFlags.ULong: case TypeFlags.Float | TypeFlags.SignedNumbers: case TypeFlags.Float | TypeFlags.UnsignedNumbers: case TypeFlags.Float | TypeFlags.ULong: case TypeFlags.ULong | TypeFlags.UnsignedNumbers: case TypeFlags.SignedNumbers | TypeFlags.UnsignedNumbers: error = null; return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); } string message2 = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message2, ErrorNumbers.Error_OperandTypesIncompatible); return null; } else { // see if they override the operator MethodInfo operatorOverride = MapOperatorToMethod(comparison, lhs, lhsExpression, rhs, rhsExpression, validator, out error); if (operatorOverride != null) return new RuleBinaryExpressionInfo(lhs, rhs, operatorOverride); // unable to evaluate, so return false return null; } } internal enum OperatorGrouping { Arithmetic, Equality, Relational } internal static MethodInfo ObjectEquality = typeof(DefaultOperators).GetMethod("ObjectEquality"); [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] // bogus since the casts are in different case statements internal static MethodInfo MapOperatorToMethod( CodeBinaryOperatorType op, Type lhs, CodeExpression lhsExpression, Type rhs, CodeExpression rhsExpression, RuleValidation validator, out ValidationError error) { // determine what the method name should be string methodName; string message; OperatorGrouping group; switch (op) { case CodeBinaryOperatorType.ValueEquality: methodName = "op_Equality"; group = OperatorGrouping.Equality; break; case CodeBinaryOperatorType.GreaterThan: methodName = "op_GreaterThan"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.GreaterThanOrEqual: methodName = "op_GreaterThanOrEqual"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.LessThan: methodName = "op_LessThan"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.LessThanOrEqual: methodName = "op_LessThanOrEqual"; group = OperatorGrouping.Relational; break; case CodeBinaryOperatorType.Add: methodName = "op_Addition"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Subtract: methodName = "op_Subtraction"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Multiply: methodName = "op_Multiply"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Divide: methodName = "op_Division"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.Modulus: methodName = "op_Modulus"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.BitwiseAnd: methodName = "op_BitwiseAnd"; group = OperatorGrouping.Arithmetic; break; case CodeBinaryOperatorType.BitwiseOr: methodName = "op_BitwiseOr"; group = OperatorGrouping.Arithmetic; break; default: Debug.Assert(false, "Operator " + op.ToString() + " not implemented"); message = string.Format(CultureInfo.CurrentCulture, Messages.BinaryOpNotSupported, op.ToString()); error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled); return null; } // NOTE: types maybe NullLiteral, which signifies the constant "null" Listcandidates = new List (); bool lhsNullable = ConditionHelper.IsNullableValueType(lhs); bool rhsNullable = ConditionHelper.IsNullableValueType(rhs); Type lhsType0 = (lhsNullable) ? Nullable.GetUnderlyingType(lhs) : lhs; Type rhsType0 = (rhsNullable) ? Nullable.GetUnderlyingType(rhs) : rhs; // special cases for enums if (lhsType0.IsEnum) { // only 3 cases (U = underlying type of E): // E = E + U // U = E - E // E = E - U // plus the standard comparisons (E == E, E > E, etc.) // need to also allow E == 0 Type underlyingType; switch (op) { case CodeBinaryOperatorType.Add: underlyingType = EnumHelper.GetUnderlyingType(lhsType0); if ((underlyingType != null) && (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error))) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } break; case CodeBinaryOperatorType.Subtract: underlyingType = EnumHelper.GetUnderlyingType(lhsType0); if (underlyingType != null) { if (lhsType0 == rhsType0) { // E - E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression)) { // E - 0, can convert 0 to E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } else if (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)) { // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } } break; case CodeBinaryOperatorType.ValueEquality: case CodeBinaryOperatorType.LessThan: case CodeBinaryOperatorType.LessThanOrEqual: case CodeBinaryOperatorType.GreaterThan: case CodeBinaryOperatorType.GreaterThanOrEqual: if (lhsType0 == rhsType0) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } else if (lhsNullable && (rhs == typeof(NullLiteral))) { // handle enum? op null // treat the rhs as the same nullable enum error = null; return new EnumOperationMethodInfo(lhs, op, lhs, false); } else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression)) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } break; } // can't do it, sorry // but check if there is a user-defined operator that works } else if (rhsType0.IsEnum) { // lhs != enum, so only 2 cases (U = underlying type of E): // E = U + E // E = U - E // comparisons are E == E, etc., so if the lhs is not an enum, too bad // although we need to check for 0 == E Type underlyingType; switch (op) { case CodeBinaryOperatorType.Add: underlyingType = EnumHelper.GetUnderlyingType(rhsType0); if ((underlyingType != null) && (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error))) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } break; case CodeBinaryOperatorType.Subtract: underlyingType = EnumHelper.GetUnderlyingType(rhsType0); if (underlyingType != null) { CodePrimitiveExpression primitive = lhsExpression as CodePrimitiveExpression; if (DecimalIntegerLiteralZero(lhs, primitive)) { // 0 - E, can convert 0 to E error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } else if (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error)) { // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) error = null; return new EnumOperationMethodInfo(lhs, op, rhs, false); } } break; case CodeBinaryOperatorType.ValueEquality: case CodeBinaryOperatorType.LessThan: case CodeBinaryOperatorType.LessThanOrEqual: case CodeBinaryOperatorType.GreaterThan: case CodeBinaryOperatorType.GreaterThanOrEqual: if (rhsNullable && (lhs == typeof(NullLiteral))) { // handle null op enum? // treat the lhs as the same nullable enum type error = null; return new EnumOperationMethodInfo(rhs, op, rhs, false); } else if (DecimalIntegerLiteralZero(lhs, lhsExpression as CodePrimitiveExpression)) { error = null; return new EnumOperationMethodInfo(lhs, op, rhs, true); } break; } // can't do it, sorry // but check if there is a user-defined operator that works } // enum specific operations already handled, see if one side (or both) define operators AddOperatorOverloads(lhsType0, methodName, lhs, rhs, candidates); AddOperatorOverloads(rhsType0, methodName, lhs, rhs, candidates); if (lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral))) { // need to add in lifted methods AddLiftedOperators(lhsType0, methodName, group, lhsType0, rhsType0, candidates); AddLiftedOperators(rhsType0, methodName, group, lhsType0, rhsType0, candidates); } if (candidates.Count == 0) { // no overrides, so get the default list methodName = methodName.Substring(3); // strip off the op_ foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) { if (mi.Name == methodName) { ParameterInfo[] parameters = mi.GetParameters(); Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; if (RuleValidation.ImplicitConversion(lhs, parm1) && RuleValidation.ImplicitConversion(rhs, parm2)) { candidates.Add(mi); } } } // if no candidates and ==, can we use object == object? if ((candidates.Count == 0) && ("Equality" == methodName)) { // C# 7.9.6 // references must be compatible // no boxing // value types can't be compared if ((!lhs.IsValueType) && (!rhs.IsValueType)) { // they are not classes, so references need to be compatible // also check for null (which is NullLiteral type) -- null is compatible with any object type if ((lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)) || (lhs.IsAssignableFrom(rhs)) || (rhs.IsAssignableFrom(lhs))) { candidates.Add(ObjectEquality); } } } // if no candidates and nullable, add lifted operators if ((candidates.Count == 0) && ((lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral))))) { foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) { if (mi.Name == methodName) { ParameterInfo[] parameters = mi.GetParameters(); MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, lhsType0, rhsType0); if (liftedMethod != null) candidates.Add(liftedMethod); } } } } if (candidates.Count == 1) { // only 1, so it is it error = null; return candidates[0]; } else if (candidates.Count == 0) { // nothing matched message = string.Format(CultureInfo.CurrentCulture, (group == OperatorGrouping.Arithmetic) ? Messages.ArithOpBadTypes : Messages.RelationalOpBadTypes, op.ToString(), (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs)); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } else { // more than 1, so pick the best one MethodInfo bestFit = validator.FindBestCandidate(null, candidates, lhs, rhs); if (bestFit != null) { error = null; return bestFit; } // must be ambiguous. Since there are at least 2 choices, show only the first 2 message = string.Format(CultureInfo.CurrentCulture, Messages.AmbiguousOperator, op.ToString(), RuleDecompiler.DecompileMethod(candidates[0]), RuleDecompiler.DecompileMethod(candidates[1])); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); return null; } } private static bool DecimalIntegerLiteralZero(Type type, CodePrimitiveExpression expression) { if (expression != null) { if (type == typeof(int)) return expression.Value.Equals(0); else if (type == typeof(uint)) return expression.Value.Equals(0U); else if (type == typeof(long)) return expression.Value.Equals(0L); else if (type == typeof(ulong)) return expression.Value.Equals(0UL); } return false; } private static void AddOperatorOverloads(Type type, string methodName, Type arg1, Type arg2, List candidates) { // append the list of methods that match the name specified int numAdded = 0; MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { if (EvaluateMethod(parameters, arg1, arg2)) { ++numAdded; if (!candidates.Contains(mi)) candidates.Add(mi); } } } if ((numAdded > 0) || (type == typeof(object))) return; // no matches, check direct base class (if there is one) type = type.BaseType; if (type != null) { possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { if (EvaluateMethod(parameters, arg1, arg2)) { if (!candidates.Contains(mi)) candidates.Add(mi); } } } } } private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List candidates) { // append the list of lifted methods that match the name specified int numAdded = 0; MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); if (liftedMethod != null) { ++numAdded; if (!candidates.Contains(liftedMethod)) candidates.Add(liftedMethod); } } } if ((numAdded > 0) || (type == typeof(object))) return; // no matches, check direct base class (if there is one) type = type.BaseType; if (type != null) { possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); foreach (MethodInfo mi in possible) { ParameterInfo[] parameters = mi.GetParameters(); if ((mi.Name == methodName) && (parameters.Length == 2)) { MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); if ((liftedMethod != null) && !candidates.Contains(liftedMethod)) candidates.Add(liftedMethod); } } } } private static bool EvaluateMethod(ParameterInfo[] parameters, Type arg1, Type arg2) { Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; return (RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)); } private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2) { Type parm1 = parameters[0].ParameterType; Type parm2 = parameters[1].ParameterType; if (ConditionHelper.IsNonNullableValueType(parm1) && ConditionHelper.IsNonNullableValueType(parm2)) { // lift the parameters for testing conversions, if possible parm1 = typeof(Nullable<>).MakeGenericType(parm1); parm2 = typeof(Nullable<>).MakeGenericType(parm2); switch (group) { case OperatorGrouping.Equality: // for == != if (mi.ReturnType == typeof(bool) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedEqualityOperatorMethodInfo(mi); } break; case OperatorGrouping.Relational: // for < > <= >= if (mi.ReturnType == typeof(bool) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedRelationalOperatorMethodInfo(mi); } break; case OperatorGrouping.Arithmetic: // for + - * / % & ^ if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) && RuleValidation.ImplicitConversion(arg1, parm1) && RuleValidation.ImplicitConversion(arg2, parm2)) { return new LiftedArithmeticOperatorMethodInfo(mi); } break; } } return null; } #endregion #region Value Type Dispatch Methods /// /// Relational equal operator /// Value-equality if we can do it, otherwise reference-equality /// /// ///internal abstract bool Equal(Literal rhs); internal virtual bool Equal(byte literalValue) { return false; } internal virtual bool Equal(sbyte literalValue) { return false; } internal virtual bool Equal(short literalValue) { return false; } internal virtual bool Equal(int literalValue) { return false; } internal virtual bool Equal(long literalValue) { return false; } internal virtual bool Equal(ushort literalValue) { return false; } internal virtual bool Equal(uint literalValue) { return false; } internal virtual bool Equal(ulong literalValue) { return false; } internal virtual bool Equal(float literalValue) { return false; } internal virtual bool Equal(double literalValue) { return false; } internal virtual bool Equal(char literalValue) { return false; } internal virtual bool Equal(string literalValue) { return false; } internal virtual bool Equal(decimal literalValue) { return false; } internal virtual bool Equal(bool literalValue) { return false; } /// /// Relational less than operator /// /// ///internal abstract bool LessThan(Literal rhs); internal virtual bool LessThan() { return false; } internal virtual bool LessThan(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } internal virtual bool LessThan(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); } /// /// Relational greater than operator /// /// ///internal abstract bool GreaterThan(Literal rhs); internal virtual bool GreaterThan() { return false; } internal virtual bool GreaterThan(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } internal virtual bool GreaterThan(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); } /// /// Relational less than or equal to operator /// /// ///internal abstract bool LessThanOrEqual(Literal rhs); internal virtual bool LessThanOrEqual() { return false; } internal virtual bool LessThanOrEqual(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } internal virtual bool LessThanOrEqual(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); } /// /// Relational greater than or equal to operator /// /// ///internal abstract bool GreaterThanOrEqual(Literal rhs); internal virtual bool GreaterThanOrEqual() { return false; } internal virtual bool GreaterThanOrEqual(byte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(char literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(sbyte literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(short literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(int literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(long literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(ushort literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(uint literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(ulong literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(float literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(double literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(string literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(decimal literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } internal virtual bool GreaterThanOrEqual(bool literalValue) { string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); } #endregion } #endregion #region Null Literal Class /// /// Represents an null literal /// internal class NullLiteral : Literal { // NOTE (from MSDN page on IComparable.CompareTo Method): // By definition, any object compares greater than a null reference // But C# (24.3.1) doesn't -- if either side is null, result is false internal NullLiteral(Type type) { m_type = type; } internal override object Value { get { return null; } } internal override bool Equal(Literal rhs) { return rhs.Value == null; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(); } internal override bool LessThan(byte literalValue) { return false; } internal override bool LessThan(char literalValue) { return false; } internal override bool LessThan(sbyte literalValue) { return false; } internal override bool LessThan(short literalValue) { return false; } internal override bool LessThan(int literalValue) { return false; } internal override bool LessThan(long literalValue) { return false; } internal override bool LessThan(ushort literalValue) { return false; } internal override bool LessThan(uint literalValue) { return false; } internal override bool LessThan(ulong literalValue) { return false; } internal override bool LessThan(float literalValue) { return false; } internal override bool LessThan(double literalValue) { return false; } internal override bool LessThan(string literalValue) { // for strings, maintain compatibility with v1 return true; } internal override bool LessThan(decimal literalValue) { return false; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(); } internal override bool GreaterThan(byte literalValue) { return false; } internal override bool GreaterThan(char literalValue) { return false; } internal override bool GreaterThan(sbyte literalValue) { return false; } internal override bool GreaterThan(short literalValue) { return false; } internal override bool GreaterThan(int literalValue) { return false; } internal override bool GreaterThan(long literalValue) { return false; } internal override bool GreaterThan(ushort literalValue) { return false; } internal override bool GreaterThan(uint literalValue) { return false; } internal override bool GreaterThan(ulong literalValue) { return false; } internal override bool GreaterThan(float literalValue) { return false; } internal override bool GreaterThan(double literalValue) { return false; } internal override bool GreaterThan(string literalValue) { return false; } internal override bool GreaterThan(decimal literalValue) { return false; } ////// Relational less than or equal to operator /// /// ///internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(); } internal override bool LessThanOrEqual() { return (m_type == typeof(string)); // null == null for strings only } internal override bool LessThanOrEqual(byte literalValue) { return false; } internal override bool LessThanOrEqual(char literalValue) { return false; } internal override bool LessThanOrEqual(sbyte literalValue) { return false; } internal override bool LessThanOrEqual(short literalValue) { return false; } internal override bool LessThanOrEqual(int literalValue) { return false; } internal override bool LessThanOrEqual(long literalValue) { return false; } internal override bool LessThanOrEqual(ushort literalValue) { return false; } internal override bool LessThanOrEqual(uint literalValue) { return false; } internal override bool LessThanOrEqual(ulong literalValue) { return false; } internal override bool LessThanOrEqual(float literalValue) { return false; } internal override bool LessThanOrEqual(double literalValue) { return false; } internal override bool LessThanOrEqual(string literalValue) { // for strings, maintain compatibility with v1 return true; } internal override bool LessThanOrEqual(decimal literalValue) { return false; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(); } internal override bool GreaterThanOrEqual() { return (m_type == typeof(string)); // null == null for strings only } internal override bool GreaterThanOrEqual(byte literalValue) { return false; } internal override bool GreaterThanOrEqual(char literalValue) { return false; } internal override bool GreaterThanOrEqual(sbyte literalValue) { return false; } internal override bool GreaterThanOrEqual(short literalValue) { return false; } internal override bool GreaterThanOrEqual(int literalValue) { return false; } internal override bool GreaterThanOrEqual(long literalValue) { return false; } internal override bool GreaterThanOrEqual(ushort literalValue) { return false; } internal override bool GreaterThanOrEqual(uint literalValue) { return false; } internal override bool GreaterThanOrEqual(ulong literalValue) { return false; } internal override bool GreaterThanOrEqual(float literalValue) { return false; } internal override bool GreaterThanOrEqual(double literalValue) { return false; } internal override bool GreaterThanOrEqual(string literalValue) { return false; } internal override bool GreaterThanOrEqual(decimal literalValue) { return false; } } #endregion #region Boolean Literal Class /// /// Represents a boolean literal /// internal class BoolLiteral : Literal { private bool m_value; internal override object Value { get { return m_value; } } internal BoolLiteral(bool literalValue) { m_value = literalValue; m_type = typeof(bool); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(bool rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } } #endregion #region Byte Literal Class ////// Represents a byte literal /// internal class ByteLiteral : Literal { private byte m_value; internal override object Value { get { return m_value; } } internal ByteLiteral(byte literalValue) { m_value = literalValue; m_type = typeof(byte); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region SByte Literal Class ////// Represents a byte literal /// internal class SByteLiteral : Literal { private sbyte m_value; internal override object Value { get { return m_value; } } internal SByteLiteral(sbyte literalValue) { m_value = literalValue; m_type = typeof(sbyte); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Char Literal Class ////// Represents a byte literal /// internal class CharLiteral : Literal { private char m_value; internal override object Value { get { return m_value; } } internal CharLiteral(char literalValue) { m_value = literalValue; m_type = typeof(char); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Decimal Literal Class ////// Represents a decimal literal /// internal class DecimalLiteral : Literal { private decimal m_value; internal override object Value { get { return m_value; } } internal DecimalLiteral(decimal literalValue) { m_value = literalValue; m_type = typeof(decimal); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int16 Literal Class ////// Represents an Int16 literal /// internal class ShortLiteral : Literal { private short m_value; internal override object Value { get { return m_value; } } internal ShortLiteral(short literalValue) { m_value = literalValue; m_type = typeof(short); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int32 Literal Class ////// Represents an Int32 literal /// internal class IntLiteral : Literal { private int m_value; internal override object Value { get { return m_value; } } internal IntLiteral(int literalValue) { m_value = literalValue; m_type = typeof(int); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return (m_value < 0) || ((ulong)m_value < rhs); } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return (m_value >= 0) && ((ulong)m_value > rhs); } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return (m_value < 0) || ((ulong)m_value <= rhs); } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return (m_value >= 0) && ((ulong)m_value >= rhs); } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Int64 Literal Class ////// Represents an Int64 literal /// internal class LongLiteral : Literal { private long m_value; internal override object Value { get { return m_value; } } internal LongLiteral(long literalValue) { m_value = literalValue; m_type = typeof(long); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return (m_value >= 0) && ((ulong)m_value == rhs); } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return (m_value < 0) || ((ulong)m_value < rhs); } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return (m_value >= 0) && ((ulong)m_value > rhs); } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return (m_value < 0) || ((ulong)m_value <= rhs); } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return (m_value >= 0) && ((ulong)m_value >= rhs); } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt16 Literal Class ////// Represents an UInt16 literal /// internal class UShortLiteral : Literal { private ushort m_value; internal override object Value { get { return m_value; } } internal UShortLiteral(ushort literalValue) { m_value = literalValue; m_type = typeof(ushort); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt32 Literal Class ////// Represents an UInt32 literal /// internal class UIntLiteral : Literal { private uint m_value; internal override object Value { get { return m_value; } } internal UIntLiteral(uint literalValue) { m_value = literalValue; m_type = typeof(uint); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region UInt64 Literal Class ////// Represents an UInt64 literal /// internal class ULongLiteral : Literal { private ulong m_value; internal override object Value { get { return m_value; } } internal ULongLiteral(ulong literalValue) { m_value = literalValue; m_type = typeof(ulong); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(sbyte rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(short rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(int rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(long rhs) { return (rhs >= 0) && (m_value == (ulong)rhs); } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool Equal(decimal rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return (rhs >= 0) && (m_value < (ulong)rhs); } internal override bool LessThan(long rhs) { return (rhs >= 0) && (m_value < (ulong)rhs); } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool LessThan(decimal rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return (rhs < 0) || (m_value > (ulong)rhs); } internal override bool GreaterThan(long rhs) { return (rhs < 0) || (m_value > (ulong)rhs); } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool GreaterThan(decimal rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return (rhs >= 0) && (m_value <= (ulong)rhs); } internal override bool LessThanOrEqual(long rhs) { return (rhs >= 0) && (m_value <= (ulong)rhs); } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(decimal rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return (rhs < 0) || (m_value >= (ulong)rhs); } internal override bool GreaterThanOrEqual(long rhs) { return (rhs < 0) || (m_value >= (ulong)rhs); } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(decimal rhs) { return m_value >= rhs; } } #endregion #region Double Literal Class ////// Represents a double literal /// internal class DoubleLiteral : Literal { private double m_value; internal override object Value { get { return m_value; } } internal DoubleLiteral(double literalValue) { m_value = literalValue; m_type = typeof(double); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } } #endregion #region Float Literal Class ////// Represents a float literal /// internal class FloatLiteral : Literal { private float m_value; internal override object Value { get { return m_value; } } internal FloatLiteral(float literalValue) { m_value = literalValue; m_type = typeof(float); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(sbyte rhs) { return m_value == rhs; } internal override bool Equal(byte rhs) { return m_value == rhs; } internal override bool Equal(char rhs) { return m_value == rhs; } internal override bool Equal(short rhs) { return m_value == rhs; } internal override bool Equal(ushort rhs) { return m_value == rhs; } internal override bool Equal(int rhs) { return m_value == rhs; } internal override bool Equal(uint rhs) { return m_value == rhs; } internal override bool Equal(long rhs) { return m_value == rhs; } internal override bool Equal(ulong rhs) { return m_value == rhs; } internal override bool Equal(float rhs) { return m_value == rhs; } internal override bool Equal(double rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(sbyte rhs) { return m_value < rhs; } internal override bool LessThan(byte rhs) { return m_value < rhs; } internal override bool LessThan(char rhs) { return m_value < rhs; } internal override bool LessThan(short rhs) { return m_value < rhs; } internal override bool LessThan(ushort rhs) { return m_value < rhs; } internal override bool LessThan(int rhs) { return m_value < rhs; } internal override bool LessThan(uint rhs) { return m_value < rhs; } internal override bool LessThan(long rhs) { return m_value < rhs; } internal override bool LessThan(ulong rhs) { return m_value < rhs; } internal override bool LessThan(float rhs) { return m_value < rhs; } internal override bool LessThan(double rhs) { return m_value < rhs; } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan(sbyte rhs) { return m_value > rhs; } internal override bool GreaterThan(byte rhs) { return m_value > rhs; } internal override bool GreaterThan(char rhs) { return m_value > rhs; } internal override bool GreaterThan(short rhs) { return m_value > rhs; } internal override bool GreaterThan(ushort rhs) { return m_value > rhs; } internal override bool GreaterThan(int rhs) { return m_value > rhs; } internal override bool GreaterThan(uint rhs) { return m_value > rhs; } internal override bool GreaterThan(long rhs) { return m_value > rhs; } internal override bool GreaterThan(ulong rhs) { return m_value > rhs; } internal override bool GreaterThan(float rhs) { return m_value > rhs; } internal override bool GreaterThan(double rhs) { return m_value > rhs; } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(sbyte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(byte rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(short rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(char rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ushort rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(int rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(uint rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(long rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(ulong rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(float rhs) { return m_value <= rhs; } internal override bool LessThanOrEqual(double rhs) { return m_value <= rhs; } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual(sbyte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(byte rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(char rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(short rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ushort rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(int rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(uint rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(long rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(ulong rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(float rhs) { return m_value >= rhs; } internal override bool GreaterThanOrEqual(double rhs) { return m_value >= rhs; } } #endregion #region String Literal Class ////// Represents a string literal /// internal class StringLiteral : Literal { private string m_value; internal override object Value { get { return m_value; } } internal StringLiteral(string internalValue) { m_value = internalValue; m_type = typeof(string); } internal override bool Equal(Literal rhs) { return rhs.Equal(m_value); } internal override bool Equal(string rhs) { return m_value == rhs; } internal override bool LessThan(Literal rhs) { return rhs.GreaterThan(m_value); } internal override bool LessThan(string rhs) { return 0 > string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool GreaterThan(Literal rhs) { return rhs.LessThan(m_value); } internal override bool GreaterThan() { return true; } internal override bool GreaterThan(string rhs) { return 0 < string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool LessThanOrEqual(Literal rhs) { return rhs.GreaterThanOrEqual(m_value); } internal override bool LessThanOrEqual(string rhs) { return 0 >= string.Compare(m_value, (string)rhs, false, System.Globalization.CultureInfo.CurrentCulture); } internal override bool GreaterThanOrEqual(Literal rhs) { return rhs.LessThanOrEqual(m_value); } internal override bool GreaterThanOrEqual() { return true; } internal override bool GreaterThanOrEqual(string rhs) { return 0 <= string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); } } #endregion } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ReaderContextStackData.cs
- Walker.cs
- DataSourceCacheDurationConverter.cs
- SafeFileMappingHandle.cs
- VisualBrush.cs
- OptimisticConcurrencyException.cs
- ErrorWrapper.cs
- SqlCommandBuilder.cs
- CustomExpressionEventArgs.cs
- FormsAuthenticationCredentials.cs
- HtmlInputHidden.cs
- OdbcConnectionOpen.cs
- CodeDefaultValueExpression.cs
- SpellerInterop.cs
- EditorPartChrome.cs
- Underline.cs
- SeekableReadStream.cs
- PageParserFilter.cs
- CompoundFileDeflateTransform.cs
- Storyboard.cs
- RawStylusActions.cs
- TriggerBase.cs
- DesignBindingPicker.cs
- ResetableIterator.cs
- HashMembershipCondition.cs
- WeakReadOnlyCollection.cs
- URL.cs
- EmissiveMaterial.cs
- X509ChainElement.cs
- FormViewInsertedEventArgs.cs
- FillErrorEventArgs.cs
- OwnerDrawPropertyBag.cs
- SerializationInfoEnumerator.cs
- HttpServerVarsCollection.cs
- CustomValidator.cs
- SplitterEvent.cs
- XmlILTrace.cs
- ListDictionaryInternal.cs
- TableProviderWrapper.cs
- HMACSHA512.cs
- QilInvokeLateBound.cs
- ListBoxItemAutomationPeer.cs
- CodeStatement.cs
- ObjectSecurity.cs
- Partitioner.cs
- PersonalizationStateQuery.cs
- RTLAwareMessageBox.cs
- AsyncOperation.cs
- SmtpNetworkElement.cs
- RandomNumberGenerator.cs
- Renderer.cs
- TemporaryBitmapFile.cs
- FileDetails.cs
- ProtocolViolationException.cs
- SystemBrushes.cs
- PersonalizationStateInfoCollection.cs
- XmlSerializerSection.cs
- SecondaryIndexDefinition.cs
- DefinitionUpdate.cs
- WrappedIUnknown.cs
- LogEntryDeserializer.cs
- ObjectCloneHelper.cs
- parserscommon.cs
- DbCommandTree.cs
- BorderGapMaskConverter.cs
- Point3DCollectionValueSerializer.cs
- BinaryConverter.cs
- StreamGeometry.cs
- MoveSizeWinEventHandler.cs
- WebControlParameterProxy.cs
- SafeNativeMethods.cs
- ACE.cs
- ProviderCommandInfoUtils.cs
- LocationSectionRecord.cs
- PackageRelationship.cs
- securitycriticaldataformultiplegetandset.cs
- GenericWebPart.cs
- TextBoxRenderer.cs
- View.cs
- ReadOnlyDataSource.cs
- BooleanFacetDescriptionElement.cs
- GifBitmapEncoder.cs
- Tokenizer.cs
- HttpCachePolicy.cs
- Crc32Helper.cs
- XmlTextReaderImplHelpers.cs
- WorkflowTraceTransfer.cs
- ToolStripItemTextRenderEventArgs.cs
- AssemblyCacheEntry.cs
- ParameterCollection.cs
- RecognizerInfo.cs
- TableLayoutSettings.cs
- SchemaNotation.cs
- MappingMetadataHelper.cs
- EmbossBitmapEffect.cs
- Menu.cs
- DeclaredTypeValidatorAttribute.cs
- Stack.cs
- NamespaceInfo.cs
- DriveNotFoundException.cs