Mercurial > pub > bltoolkit
view Source/Common/Operator.cs @ 8:a34cfdde80d6
removed strong signing
added FrameworkPathOverride for linux builds
| author | cin |
|---|---|
| date | Wed, 29 Nov 2017 12:43:52 +0300 |
| parents | f990fcb411a9 |
| children |
line wrap: on
line source
using System; using System.Data.SqlTypes; namespace BLToolkit.Common { public static class Operator<T> { public static IOperable<T> Op = GetOperable(); private static IOperable<T> GetOperable() { Type t = typeof(T); // Scalar types. // if (t == typeof(String)) return (IOperable<T>)new S(); if (t == typeof(SByte)) return (IOperable<T>)new S8(); if (t == typeof(Int16)) return (IOperable<T>)new S16(); if (t == typeof(Int32)) return (IOperable<T>)new S32(); if (t == typeof(Int64)) return (IOperable<T>)new S64(); if (t == typeof(Byte)) return (IOperable<T>)new U8(); if (t == typeof(UInt16)) return (IOperable<T>)new U16(); if (t == typeof(UInt32)) return (IOperable<T>)new U32(); if (t == typeof(UInt64)) return (IOperable<T>)new U64(); if (t == typeof(bool)) return (IOperable<T>)new B(); if (t == typeof(Char)) return (IOperable<T>)new C(); if (t == typeof(Single)) return (IOperable<T>)new R4(); if (t == typeof(Double)) return (IOperable<T>)new R8(); if (t == typeof(Decimal)) return (IOperable<T>)new D(); if (t == typeof(DateTime)) return (IOperable<T>)new DT(); if (t == typeof(TimeSpan)) return (IOperable<T>)new TS(); if (t == typeof(Guid)) return (IOperable<T>)new G(); // Nullable types. // if (t == typeof(SByte?)) return (IOperable<T>)new NS8(); if (t == typeof(Int16?)) return (IOperable<T>)new NS16(); if (t == typeof(Int32?)) return (IOperable<T>)new NS32(); if (t == typeof(Int64?)) return (IOperable<T>)new NS64(); if (t == typeof(Byte?)) return (IOperable<T>)new NU8(); if (t == typeof(UInt16?)) return (IOperable<T>)new NU16(); if (t == typeof(UInt32?)) return (IOperable<T>)new NU32(); if (t == typeof(UInt64?)) return (IOperable<T>)new NU64(); if (t == typeof(bool?)) return (IOperable<T>)new NB(); if (t == typeof(Char?)) return (IOperable<T>)new NC(); if (t == typeof(Single?)) return (IOperable<T>)new NR4(); if (t == typeof(Double?)) return (IOperable<T>)new NR8(); if (t == typeof(Decimal?)) return (IOperable<T>)new ND(); if (t == typeof(DateTime?)) return (IOperable<T>)new NDT(); if (t == typeof(TimeSpan?)) return (IOperable<T>)new NTS(); if (t == typeof(Guid?)) return (IOperable<T>)new NG(); // Sql types. // if (t == typeof(SqlString)) return (IOperable<T>)new DBS(); if (t == typeof(SqlByte)) return (IOperable<T>)new DBU8(); if (t == typeof(SqlInt16)) return (IOperable<T>)new DBS16(); if (t == typeof(SqlInt32)) return (IOperable<T>)new DBS32(); if (t == typeof(SqlInt64)) return (IOperable<T>)new DBS64(); if (t == typeof(SqlSingle)) return (IOperable<T>)new DBR4(); if (t == typeof(SqlDouble)) return (IOperable<T>)new DBR8(); if (t == typeof(SqlDecimal)) return (IOperable<T>)new DBD(); if (t == typeof(SqlMoney)) return (IOperable<T>)new DBM(); if (t == typeof(SqlBoolean)) return (IOperable<T>)new DBB(); if (t == typeof(SqlBinary)) return (IOperable<T>)new DBBin(); if (t == typeof(SqlDateTime)) return (IOperable<T>)new DBDT(); if (t == typeof(SqlGuid)) return (IOperable<T>)new DBG(); return new Default<T>(); } public static T Addition (T op1, T op2) { return Op.Addition (op1, op2); } public static T Subtraction (T op1, T op2) { return Op.Subtraction (op1, op2); } public static T Multiply (T op1, T op2) { return Op.Multiply (op1, op2); } public static T Division (T op1, T op2) { return Op.Division (op1, op2); } public static T Modulus (T op1, T op2) { return Op.Modulus (op1, op2); } public static T BitwiseAnd (T op1, T op2) { return Op.BitwiseAnd (op1, op2); } public static T BitwiseOr (T op1, T op2) { return Op.BitwiseOr (op1, op2); } public static T ExclusiveOr (T op1, T op2) { return Op.ExclusiveOr (op1, op2); } public static T UnaryNegation (T op) { return Op.UnaryNegation (op); } public static T OnesComplement (T op) { return Op.OnesComplement (op); } public static bool Equality (T op1, T op2) { return Op.Equality (op1, op2); } public static bool Inequality (T op1, T op2) { return Op.Inequality (op1, op2); } public static bool GreaterThan (T op1, T op2) { return Op.GreaterThan (op1, op2); } public static bool GreaterThanOrEqual(T op1, T op2) { return Op.GreaterThanOrEqual(op1, op2); } public static bool LessThan (T op1, T op2) { return Op.LessThan (op1, op2); } public static bool LessThanOrEqual (T op1, T op2) { return Op.LessThanOrEqual (op1, op2); } #region Default private class Default<Q> : IOperable<Q> { public Q Addition (Q op1, Q op2) { throw new InvalidOperationException(); } public Q Subtraction (Q op1, Q op2) { throw new InvalidOperationException(); } public Q Multiply (Q op1, Q op2) { throw new InvalidOperationException(); } public Q Division (Q op1, Q op2) { throw new InvalidOperationException(); } public Q Modulus (Q op1, Q op2) { throw new InvalidOperationException(); } public Q BitwiseAnd (Q op1, Q op2) { throw new InvalidOperationException(); } public Q BitwiseOr (Q op1, Q op2) { throw new InvalidOperationException(); } public Q ExclusiveOr (Q op1, Q op2) { throw new InvalidOperationException(); } public Q UnaryNegation (Q op) { throw new InvalidOperationException(); } public Q OnesComplement (Q op) { throw new InvalidOperationException(); } public bool Equality (Q op1, Q op2) { throw new InvalidOperationException(); } public bool Inequality (Q op1, Q op2) { throw new InvalidOperationException(); } public bool GreaterThan (Q op1, Q op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(Q op1, Q op2) { throw new InvalidOperationException(); } public bool LessThan (Q op1, Q op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (Q op1, Q op2) { throw new InvalidOperationException(); } } #endregion #region Scalar Types. #region String private class S : IOperable<String> { public String Addition (String op1, String op2) { return (op1 + op2); } public String Subtraction (String op1, String op2) { throw new InvalidOperationException(); } public String Multiply (String op1, String op2) { throw new InvalidOperationException(); } public String Division (String op1, String op2) { throw new InvalidOperationException(); } public String Modulus (String op1, String op2) { throw new InvalidOperationException(); } public String BitwiseAnd (String op1, String op2) { throw new InvalidOperationException(); } public String BitwiseOr (String op1, String op2) { throw new InvalidOperationException(); } public String ExclusiveOr (String op1, String op2) { throw new InvalidOperationException(); } public String UnaryNegation (String op) { throw new InvalidOperationException(); } public String OnesComplement (String op) { throw new InvalidOperationException(); } public bool Equality (String op1, String op2) { return op1 == op2; } public bool Inequality (String op1, String op2) { return op1 != op2; } public bool GreaterThan (String op1, String op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(String op1, String op2) { throw new InvalidOperationException(); } public bool LessThan (String op1, String op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (String op1, String op2) { throw new InvalidOperationException(); } } #endregion #region SByte private class S8 : IOperable<SByte> { public SByte Addition (SByte op1, SByte op2) { return (SByte)(op1 + op2); } public SByte Subtraction (SByte op1, SByte op2) { return (SByte)(op1 - op2); } public SByte Multiply (SByte op1, SByte op2) { return (SByte)(op1 * op2); } public SByte Division (SByte op1, SByte op2) { return (SByte)(op1 / op2); } public SByte Modulus (SByte op1, SByte op2) { return (SByte)(op1 % op2); } public SByte BitwiseAnd (SByte op1, SByte op2) { return (SByte)(op1 & op2); } public SByte BitwiseOr (SByte op1, SByte op2) { return (SByte)(op1 | op2); } public SByte ExclusiveOr (SByte op1, SByte op2) { return (SByte)(op1 ^ op2); } public SByte UnaryNegation (SByte op) { return (SByte)(-op); } public SByte OnesComplement (SByte op) { return (SByte)(~op); } public bool Equality (SByte op1, SByte op2) { return op1 == op2; } public bool Inequality (SByte op1, SByte op2) { return op1 != op2; } public bool GreaterThan (SByte op1, SByte op2) { return op1 > op2; } public bool GreaterThanOrEqual(SByte op1, SByte op2) { return op1 >= op2; } public bool LessThan (SByte op1, SByte op2) { return op1 < op2; } public bool LessThanOrEqual (SByte op1, SByte op2) { return op1 <= op2; } } #endregion #region Int16 private class S16 : IOperable<Int16> { public Int16 Addition (Int16 op1, Int16 op2) { return (Int16)(op1 + op2); } public Int16 Subtraction (Int16 op1, Int16 op2) { return (Int16)(op1 - op2); } public Int16 Multiply (Int16 op1, Int16 op2) { return (Int16)(op1 * op2); } public Int16 Division (Int16 op1, Int16 op2) { return (Int16)(op1 / op2); } public Int16 Modulus (Int16 op1, Int16 op2) { return (Int16)(op1 % op2); } public Int16 BitwiseAnd (Int16 op1, Int16 op2) { return (Int16)(op1 & op2); } public Int16 BitwiseOr (Int16 op1, Int16 op2) { return (Int16)(op1 | op2); } public Int16 ExclusiveOr (Int16 op1, Int16 op2) { return (Int16)(op1 ^ op2); } public Int16 UnaryNegation (Int16 op) { return (Int16)(-op); } public Int16 OnesComplement (Int16 op) { return (Int16)(~op); } public bool Equality (Int16 op1, Int16 op2) { return op1 == op2; } public bool Inequality (Int16 op1, Int16 op2) { return op1 != op2; } public bool GreaterThan (Int16 op1, Int16 op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int16 op1, Int16 op2) { return op1 >= op2; } public bool LessThan (Int16 op1, Int16 op2) { return op1 < op2; } public bool LessThanOrEqual (Int16 op1, Int16 op2) { return op1 <= op2; } } #endregion #region Int32 private class S32 : IOperable<Int32> { public Int32 Addition (Int32 op1, Int32 op2) { return (op1 + op2); } public Int32 Subtraction (Int32 op1, Int32 op2) { return (op1 - op2); } public Int32 Multiply (Int32 op1, Int32 op2) { return (op1 * op2); } public Int32 Division (Int32 op1, Int32 op2) { return (op1 / op2); } public Int32 Modulus (Int32 op1, Int32 op2) { return (op1 % op2); } public Int32 BitwiseAnd (Int32 op1, Int32 op2) { return (op1 & op2); } public Int32 BitwiseOr (Int32 op1, Int32 op2) { return (op1 | op2); } public Int32 ExclusiveOr (Int32 op1, Int32 op2) { return (op1 ^ op2); } public Int32 UnaryNegation (Int32 op) { return (-op); } public Int32 OnesComplement (Int32 op) { return (~op); } public bool Equality (Int32 op1, Int32 op2) { return op1 == op2; } public bool Inequality (Int32 op1, Int32 op2) { return op1 != op2; } public bool GreaterThan (Int32 op1, Int32 op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int32 op1, Int32 op2) { return op1 >= op2; } public bool LessThan (Int32 op1, Int32 op2) { return op1 < op2; } public bool LessThanOrEqual (Int32 op1, Int32 op2) { return op1 <= op2; } } #endregion #region Int64 private class S64 : IOperable<Int64> { public Int64 Addition (Int64 op1, Int64 op2) { return (op1 + op2); } public Int64 Subtraction (Int64 op1, Int64 op2) { return (op1 - op2); } public Int64 Multiply (Int64 op1, Int64 op2) { return (op1 * op2); } public Int64 Division (Int64 op1, Int64 op2) { return (op1 / op2); } public Int64 Modulus (Int64 op1, Int64 op2) { return (op1 % op2); } public Int64 BitwiseAnd (Int64 op1, Int64 op2) { return (op1 & op2); } public Int64 BitwiseOr (Int64 op1, Int64 op2) { return (op1 | op2); } public Int64 ExclusiveOr (Int64 op1, Int64 op2) { return (op1 ^ op2); } public Int64 UnaryNegation (Int64 op) { return (-op); } public Int64 OnesComplement (Int64 op) { return (~op); } public bool Equality (Int64 op1, Int64 op2) { return op1 == op2; } public bool Inequality (Int64 op1, Int64 op2) { return op1 != op2; } public bool GreaterThan (Int64 op1, Int64 op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int64 op1, Int64 op2) { return op1 >= op2; } public bool LessThan (Int64 op1, Int64 op2) { return op1 < op2; } public bool LessThanOrEqual (Int64 op1, Int64 op2) { return op1 <= op2; } } #endregion #region Byte private class U8 : IOperable<Byte> { public Byte Addition (Byte op1, Byte op2) { return (Byte)(op1 + op2); } public Byte Subtraction (Byte op1, Byte op2) { return (Byte)(op1 - op2); } public Byte Multiply (Byte op1, Byte op2) { return (Byte)(op1 * op2); } public Byte Division (Byte op1, Byte op2) { return (Byte)(op1 / op2); } public Byte Modulus (Byte op1, Byte op2) { return (Byte)(op1 % op2); } public Byte BitwiseAnd (Byte op1, Byte op2) { return (Byte)(op1 & op2); } public Byte BitwiseOr (Byte op1, Byte op2) { return (Byte)(op1 | op2); } public Byte ExclusiveOr (Byte op1, Byte op2) { return (Byte)(op1 ^ op2); } public Byte UnaryNegation (Byte op) { throw new InvalidOperationException(); } public Byte OnesComplement (Byte op) { return (Byte)(~op); } public bool Equality (Byte op1, Byte op2) { return op1 == op2; } public bool Inequality (Byte op1, Byte op2) { return op1 != op2; } public bool GreaterThan (Byte op1, Byte op2) { return op1 > op2; } public bool GreaterThanOrEqual(Byte op1, Byte op2) { return op1 >= op2; } public bool LessThan (Byte op1, Byte op2) { return op1 < op2; } public bool LessThanOrEqual (Byte op1, Byte op2) { return op1 <= op2; } } #endregion #region UInt16 private class U16 : IOperable<UInt16> { public UInt16 Addition (UInt16 op1, UInt16 op2) { return (UInt16)(op1 + op2); } public UInt16 Subtraction (UInt16 op1, UInt16 op2) { return (UInt16)(op1 - op2); } public UInt16 Multiply (UInt16 op1, UInt16 op2) { return (UInt16)(op1 * op2); } public UInt16 Division (UInt16 op1, UInt16 op2) { return (UInt16)(op1 / op2); } public UInt16 Modulus (UInt16 op1, UInt16 op2) { return (UInt16)(op1 % op2); } public UInt16 BitwiseAnd (UInt16 op1, UInt16 op2) { return (UInt16)(op1 & op2); } public UInt16 BitwiseOr (UInt16 op1, UInt16 op2) { return (UInt16)(op1 | op2); } public UInt16 ExclusiveOr (UInt16 op1, UInt16 op2) { return (UInt16)(op1 ^ op2); } public UInt16 UnaryNegation (UInt16 op) { throw new InvalidOperationException(); } public UInt16 OnesComplement (UInt16 op) { return (UInt16)(~op); } public bool Equality (UInt16 op1, UInt16 op2) { return op1 == op2; } public bool Inequality (UInt16 op1, UInt16 op2) { return op1 != op2; } public bool GreaterThan (UInt16 op1, UInt16 op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt16 op1, UInt16 op2) { return op1 >= op2; } public bool LessThan (UInt16 op1, UInt16 op2) { return op1 < op2; } public bool LessThanOrEqual (UInt16 op1, UInt16 op2) { return op1 <= op2; } } #endregion #region UInt32 private class U32 : IOperable<UInt32> { public UInt32 Addition (UInt32 op1, UInt32 op2) { return (op1 + op2); } public UInt32 Subtraction (UInt32 op1, UInt32 op2) { return (op1 - op2); } public UInt32 Multiply (UInt32 op1, UInt32 op2) { return (op1 * op2); } public UInt32 Division (UInt32 op1, UInt32 op2) { return (op1 / op2); } public UInt32 Modulus (UInt32 op1, UInt32 op2) { return (op1 % op2); } public UInt32 BitwiseAnd (UInt32 op1, UInt32 op2) { return (op1 & op2); } public UInt32 BitwiseOr (UInt32 op1, UInt32 op2) { return (op1 | op2); } public UInt32 ExclusiveOr (UInt32 op1, UInt32 op2) { return (op1 ^ op2); } public UInt32 UnaryNegation (UInt32 op) { throw new InvalidOperationException(); } public UInt32 OnesComplement (UInt32 op) { return (~op); } public bool Equality (UInt32 op1, UInt32 op2) { return op1 == op2; } public bool Inequality (UInt32 op1, UInt32 op2) { return op1 != op2; } public bool GreaterThan (UInt32 op1, UInt32 op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt32 op1, UInt32 op2) { return op1 >= op2; } public bool LessThan (UInt32 op1, UInt32 op2) { return op1 < op2; } public bool LessThanOrEqual (UInt32 op1, UInt32 op2) { return op1 <= op2; } } #endregion #region UInt64 private class U64 : IOperable<UInt64> { public UInt64 Addition (UInt64 op1, UInt64 op2) { return (op1 + op2); } public UInt64 Subtraction (UInt64 op1, UInt64 op2) { return (op1 - op2); } public UInt64 Multiply (UInt64 op1, UInt64 op2) { return (op1 * op2); } public UInt64 Division (UInt64 op1, UInt64 op2) { return (op1 / op2); } public UInt64 Modulus (UInt64 op1, UInt64 op2) { return (op1 % op2); } public UInt64 BitwiseAnd (UInt64 op1, UInt64 op2) { return (op1 & op2); } public UInt64 BitwiseOr (UInt64 op1, UInt64 op2) { return (op1 | op2); } public UInt64 ExclusiveOr (UInt64 op1, UInt64 op2) { return (op1 ^ op2); } public UInt64 UnaryNegation (UInt64 op) { throw new InvalidOperationException(); } public UInt64 OnesComplement (UInt64 op) { return (~op); } public bool Equality (UInt64 op1, UInt64 op2) { return op1 == op2; } public bool Inequality (UInt64 op1, UInt64 op2) { return op1 != op2; } public bool GreaterThan (UInt64 op1, UInt64 op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt64 op1, UInt64 op2) { return op1 >= op2; } public bool LessThan (UInt64 op1, UInt64 op2) { return op1 < op2; } public bool LessThanOrEqual (UInt64 op1, UInt64 op2) { return op1 <= op2; } } #endregion #region Boolean private class B : IOperable<Boolean> { public Boolean Addition (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public Boolean Subtraction (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public Boolean Multiply (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public Boolean Division (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public Boolean Modulus (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public Boolean BitwiseAnd (Boolean op1, Boolean op2) { return (op1 & op2); } public Boolean BitwiseOr (Boolean op1, Boolean op2) { return (op1 | op2); } public Boolean ExclusiveOr (Boolean op1, Boolean op2) { return (op1 ^ op2); } public Boolean UnaryNegation (Boolean op) { throw new InvalidOperationException(); } public Boolean OnesComplement (Boolean op) { return !op; } public bool Equality (Boolean op1, Boolean op2) { return op1 == op2; } public bool Inequality (Boolean op1, Boolean op2) { return op1 != op2; } public bool GreaterThan (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public bool LessThan (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (Boolean op1, Boolean op2) { throw new InvalidOperationException(); } } #endregion #region Char private class C : IOperable<Char> { public Char Addition (Char op1, Char op2) { return (Char)(op1 + op2); } public Char Subtraction (Char op1, Char op2) { return (Char)(op1 - op2); } public Char Multiply (Char op1, Char op2) { return (Char)(op1 * op2); } public Char Division (Char op1, Char op2) { return (Char)(op1 / op2); } public Char Modulus (Char op1, Char op2) { return (Char)(op1 % op2); } public Char BitwiseAnd (Char op1, Char op2) { return (Char)(op1 & op2); } public Char BitwiseOr (Char op1, Char op2) { return (Char)(op1 | op2); } public Char ExclusiveOr (Char op1, Char op2) { return (Char)(op1 ^ op2); } public Char UnaryNegation (Char op) { return (Char)(-op); } public Char OnesComplement (Char op) { return (Char)(~op); } public bool Equality (Char op1, Char op2) { return op1 == op2; } public bool Inequality (Char op1, Char op2) { return op1 != op2; } public bool GreaterThan (Char op1, Char op2) { return op1 > op2; } public bool GreaterThanOrEqual(Char op1, Char op2) { return op1 >= op2; } public bool LessThan (Char op1, Char op2) { return op1 < op2; } public bool LessThanOrEqual (Char op1, Char op2) { return op1 <= op2; } } #endregion #region Single private class R4 : IOperable<Single> { public Single Addition (Single op1, Single op2) { return (op1 + op2); } public Single Subtraction (Single op1, Single op2) { return (op1 - op2); } public Single Multiply (Single op1, Single op2) { return (op1 * op2); } public Single Division (Single op1, Single op2) { return (op1 / op2); } public Single Modulus (Single op1, Single op2) { return (op1 % op2); } public Single BitwiseAnd (Single op1, Single op2) { throw new InvalidOperationException(); } public Single BitwiseOr (Single op1, Single op2) { throw new InvalidOperationException(); } public Single ExclusiveOr (Single op1, Single op2) { throw new InvalidOperationException(); } public Single UnaryNegation (Single op) { return (-op); } public Single OnesComplement (Single op) { throw new InvalidOperationException(); } public bool Equality (Single op1, Single op2) { return op1 == op2; } public bool Inequality (Single op1, Single op2) { return op1 != op2; } public bool GreaterThan (Single op1, Single op2) { return op1 > op2; } public bool GreaterThanOrEqual(Single op1, Single op2) { return op1 >= op2; } public bool LessThan (Single op1, Single op2) { return op1 < op2; } public bool LessThanOrEqual (Single op1, Single op2) { return op1 <= op2; } } #endregion #region Double private class R8 : IOperable<Double> { public Double Addition (Double op1, Double op2) { return (op1 + op2); } public Double Subtraction (Double op1, Double op2) { return (op1 - op2); } public Double Multiply (Double op1, Double op2) { return (op1 * op2); } public Double Division (Double op1, Double op2) { return (op1 / op2); } public Double Modulus (Double op1, Double op2) { return (op1 % op2); } public Double BitwiseAnd (Double op1, Double op2) { throw new InvalidOperationException(); } public Double BitwiseOr (Double op1, Double op2) { throw new InvalidOperationException(); } public Double ExclusiveOr (Double op1, Double op2) { throw new InvalidOperationException(); } public Double UnaryNegation (Double op) { return (-op); } public Double OnesComplement (Double op) { throw new InvalidOperationException(); } public bool Equality (Double op1, Double op2) { return op1 == op2; } public bool Inequality (Double op1, Double op2) { return op1 != op2; } public bool GreaterThan (Double op1, Double op2) { return op1 > op2; } public bool GreaterThanOrEqual(Double op1, Double op2) { return op1 >= op2; } public bool LessThan (Double op1, Double op2) { return op1 < op2; } public bool LessThanOrEqual (Double op1, Double op2) { return op1 <= op2; } } #endregion #region Decimal private class D : IOperable<Decimal> { public Decimal Addition (Decimal op1, Decimal op2) { return (op1 + op2); } public Decimal Subtraction (Decimal op1, Decimal op2) { return (op1 - op2); } public Decimal Multiply (Decimal op1, Decimal op2) { return (op1 * op2); } public Decimal Division (Decimal op1, Decimal op2) { return (op1 / op2); } public Decimal Modulus (Decimal op1, Decimal op2) { return (op1 % op2); } public Decimal BitwiseAnd (Decimal op1, Decimal op2) { throw new InvalidOperationException(); } public Decimal BitwiseOr (Decimal op1, Decimal op2) { throw new InvalidOperationException(); } public Decimal ExclusiveOr (Decimal op1, Decimal op2) { throw new InvalidOperationException(); } public Decimal UnaryNegation (Decimal op) { return (-op); } public Decimal OnesComplement (Decimal op) { throw new InvalidOperationException(); } public bool Equality (Decimal op1, Decimal op2) { return op1 == op2; } public bool Inequality (Decimal op1, Decimal op2) { return op1 != op2; } public bool GreaterThan (Decimal op1, Decimal op2) { return op1 > op2; } public bool GreaterThanOrEqual(Decimal op1, Decimal op2) { return op1 >= op2; } public bool LessThan (Decimal op1, Decimal op2) { return op1 < op2; } public bool LessThanOrEqual (Decimal op1, Decimal op2) { return op1 <= op2; } } #endregion #region DateTime private class DT : IOperable<DateTime> { public DateTime Addition (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime Subtraction (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime Multiply (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime Division (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime Modulus (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime BitwiseAnd (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime BitwiseOr (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime ExclusiveOr (DateTime op1, DateTime op2) { throw new InvalidOperationException(); } public DateTime UnaryNegation (DateTime op) { throw new InvalidOperationException(); } public DateTime OnesComplement(DateTime op) { throw new InvalidOperationException(); } public bool Equality (DateTime op1, DateTime op2) { return op1 == op2; } public bool Inequality (DateTime op1, DateTime op2) { return op1 != op2; } public bool GreaterThan (DateTime op1, DateTime op2) { return op1 > op2; } public bool GreaterThanOrEqual(DateTime op1, DateTime op2) { return op1 >= op2; } public bool LessThan (DateTime op1, DateTime op2) { return op1 < op2; } public bool LessThanOrEqual (DateTime op1, DateTime op2) { return op1 <= op2; } } #endregion #region TimeSpan private class TS : IOperable<TimeSpan> { public TimeSpan Addition (TimeSpan op1, TimeSpan op2) { return (op1 + op2); } public TimeSpan Subtraction (TimeSpan op1, TimeSpan op2) { return (op1 - op2); } public TimeSpan Multiply (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan Division (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan Modulus (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan BitwiseAnd (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan BitwiseOr (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan ExclusiveOr (TimeSpan op1, TimeSpan op2) { throw new InvalidOperationException(); } public TimeSpan UnaryNegation (TimeSpan op) { return (-op); } public TimeSpan OnesComplement(TimeSpan op) { throw new InvalidOperationException(); } public bool Equality (TimeSpan op1, TimeSpan op2) { return op1 == op2; } public bool Inequality (TimeSpan op1, TimeSpan op2) { return op1 != op2; } public bool GreaterThan (TimeSpan op1, TimeSpan op2) { return op1 > op2; } public bool GreaterThanOrEqual(TimeSpan op1, TimeSpan op2) { return op1 >= op2; } public bool LessThan (TimeSpan op1, TimeSpan op2) { return op1 < op2; } public bool LessThanOrEqual (TimeSpan op1, TimeSpan op2) { return op1 <= op2; } } #endregion #region Guid private class G : IOperable<Guid> { public Guid Addition (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid Subtraction (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid Multiply (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid Division (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid Modulus (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid BitwiseAnd (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid BitwiseOr (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid ExclusiveOr (Guid op1, Guid op2) { throw new InvalidOperationException(); } public Guid UnaryNegation (Guid op) { throw new InvalidOperationException(); } public Guid OnesComplement (Guid op) { throw new InvalidOperationException(); } public bool Equality (Guid op1, Guid op2) { return op1 == op2; } public bool Inequality (Guid op1, Guid op2) { return op1 != op2; } public bool GreaterThan (Guid op1, Guid op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(Guid op1, Guid op2) { throw new InvalidOperationException(); } public bool LessThan (Guid op1, Guid op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (Guid op1, Guid op2) { throw new InvalidOperationException(); } } #endregion #endregion #region Nullable Types. #region SByte private class NS8 : IOperable<SByte?> { public SByte? Addition (SByte? op1, SByte? op2) { return (SByte?)(op1 + op2); } public SByte? Subtraction (SByte? op1, SByte? op2) { return (SByte?)(op1 - op2); } public SByte? Multiply (SByte? op1, SByte? op2) { return (SByte?)(op1 * op2); } public SByte? Division (SByte? op1, SByte? op2) { return (SByte?)(op1 / op2); } public SByte? Modulus (SByte? op1, SByte? op2) { return (SByte?)(op1 % op2); } public SByte? BitwiseAnd (SByte? op1, SByte? op2) { return (SByte?)(op1 & op2); } public SByte? BitwiseOr (SByte? op1, SByte? op2) { return (SByte?)(op1 | op2); } public SByte? ExclusiveOr (SByte? op1, SByte? op2) { return (SByte?)(op1 ^ op2); } public SByte? UnaryNegation (SByte? op) { return (SByte)(- op); } public SByte? OnesComplement (SByte? op) { return (SByte)(~op); } public bool Equality (SByte? op1, SByte? op2) { return op1 == op2; } public bool Inequality (SByte? op1, SByte? op2) { return op1 != op2; } public bool GreaterThan (SByte? op1, SByte? op2) { return op1 > op2; } public bool GreaterThanOrEqual(SByte? op1, SByte? op2) { return op1 >= op2; } public bool LessThan (SByte? op1, SByte? op2) { return op1 < op2; } public bool LessThanOrEqual (SByte? op1, SByte? op2) { return op1 <= op2; } } #endregion #region Int16 private class NS16 : IOperable<Int16?> { public Int16? Addition (Int16? op1, Int16? op2) { return (Int16?)(op1 + op2); } public Int16? Subtraction (Int16? op1, Int16? op2) { return (Int16?)(op1 - op2); } public Int16? Multiply (Int16? op1, Int16? op2) { return (Int16?)(op1 * op2); } public Int16? Division (Int16? op1, Int16? op2) { return (Int16?)(op1 / op2); } public Int16? Modulus (Int16? op1, Int16? op2) { return (Int16?)(op1 % op2); } public Int16? BitwiseAnd (Int16? op1, Int16? op2) { return (Int16?)(op1 & op2); } public Int16? BitwiseOr (Int16? op1, Int16? op2) { return (Int16?)(op1 | op2); } public Int16? ExclusiveOr (Int16? op1, Int16? op2) { return (Int16?)(op1 ^ op2); } public Int16? UnaryNegation (Int16? op) { return (Int16)(- op); } public Int16? OnesComplement (Int16? op) { return (Int16)(~op); } public bool Equality (Int16? op1, Int16? op2) { return op1 == op2; } public bool Inequality (Int16? op1, Int16? op2) { return op1 != op2; } public bool GreaterThan (Int16? op1, Int16? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int16? op1, Int16? op2) { return op1 >= op2; } public bool LessThan (Int16? op1, Int16? op2) { return op1 < op2; } public bool LessThanOrEqual (Int16? op1, Int16? op2) { return op1 <= op2; } } #endregion #region Int32 private class NS32 : IOperable<Int32?> { public Int32? Addition (Int32? op1, Int32? op2) { return (op1 + op2); } public Int32? Subtraction (Int32? op1, Int32? op2) { return (op1 - op2); } public Int32? Multiply (Int32? op1, Int32? op2) { return (op1 * op2); } public Int32? Division (Int32? op1, Int32? op2) { return (op1 / op2); } public Int32? Modulus (Int32? op1, Int32? op2) { return (op1 % op2); } public Int32? BitwiseAnd (Int32? op1, Int32? op2) { return (op1 & op2); } public Int32? BitwiseOr (Int32? op1, Int32? op2) { return (op1 | op2); } public Int32? ExclusiveOr (Int32? op1, Int32? op2) { return (op1 ^ op2); } public Int32? UnaryNegation (Int32? op) { return (- op); } public Int32? OnesComplement (Int32? op) { return (~op); } public bool Equality (Int32? op1, Int32? op2) { return op1 == op2; } public bool Inequality (Int32? op1, Int32? op2) { return op1 != op2; } public bool GreaterThan (Int32? op1, Int32? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int32? op1, Int32? op2) { return op1 >= op2; } public bool LessThan (Int32? op1, Int32? op2) { return op1 < op2; } public bool LessThanOrEqual (Int32? op1, Int32? op2) { return op1 <= op2; } } #endregion #region Int64 private class NS64 : IOperable<Int64?> { public Int64? Addition (Int64? op1, Int64? op2) { return (op1 + op2); } public Int64? Subtraction (Int64? op1, Int64? op2) { return (op1 - op2); } public Int64? Multiply (Int64? op1, Int64? op2) { return (op1 * op2); } public Int64? Division (Int64? op1, Int64? op2) { return (op1 / op2); } public Int64? Modulus (Int64? op1, Int64? op2) { return (op1 % op2); } public Int64? BitwiseAnd (Int64? op1, Int64? op2) { return (op1 & op2); } public Int64? BitwiseOr (Int64? op1, Int64? op2) { return (op1 | op2); } public Int64? ExclusiveOr (Int64? op1, Int64? op2) { return (op1 ^ op2); } public Int64? UnaryNegation (Int64? op) { return (- op); } public Int64? OnesComplement (Int64? op) { return (~op); } public bool Equality (Int64? op1, Int64? op2) { return op1 == op2; } public bool Inequality (Int64? op1, Int64? op2) { return op1 != op2; } public bool GreaterThan (Int64? op1, Int64? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Int64? op1, Int64? op2) { return op1 >= op2; } public bool LessThan (Int64? op1, Int64? op2) { return op1 < op2; } public bool LessThanOrEqual (Int64? op1, Int64? op2) { return op1 <= op2; } } #endregion #region Byte private class NU8 : IOperable<Byte?> { public Byte? Addition (Byte? op1, Byte? op2) { return (Byte?)(op1 + op2); } public Byte? Subtraction (Byte? op1, Byte? op2) { return (Byte?)(op1 - op2); } public Byte? Multiply (Byte? op1, Byte? op2) { return (Byte?)(op1 * op2); } public Byte? Division (Byte? op1, Byte? op2) { return (Byte?)(op1 / op2); } public Byte? Modulus (Byte? op1, Byte? op2) { return (Byte?)(op1 % op2); } public Byte? BitwiseAnd (Byte? op1, Byte? op2) { return (Byte?)(op1 & op2); } public Byte? BitwiseOr (Byte? op1, Byte? op2) { return (Byte?)(op1 | op2); } public Byte? ExclusiveOr (Byte? op1, Byte? op2) { return (Byte?)(op1 ^ op2); } public Byte? UnaryNegation (Byte? op) { throw new InvalidOperationException(); } public Byte? OnesComplement (Byte? op) { return (Byte?)(~op); } public bool Equality (Byte? op1, Byte? op2) { return op1 == op2; } public bool Inequality (Byte? op1, Byte? op2) { return op1 != op2; } public bool GreaterThan (Byte? op1, Byte? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Byte? op1, Byte? op2) { return op1 >= op2; } public bool LessThan (Byte? op1, Byte? op2) { return op1 < op2; } public bool LessThanOrEqual (Byte? op1, Byte? op2) { return op1 <= op2; } } #endregion #region UInt16 private class NU16 : IOperable<UInt16?> { public UInt16? Addition (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 + op2); } public UInt16? Subtraction (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 - op2); } public UInt16? Multiply (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 * op2); } public UInt16? Division (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 / op2); } public UInt16? Modulus (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 % op2); } public UInt16? BitwiseAnd (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 & op2); } public UInt16? BitwiseOr (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 | op2); } public UInt16? ExclusiveOr (UInt16? op1, UInt16? op2) { return (UInt16?)(op1 ^ op2); } public UInt16? UnaryNegation (UInt16? op) { throw new InvalidOperationException(); } public UInt16? OnesComplement (UInt16? op) { return (UInt16?)(~op); } public bool Equality (UInt16? op1, UInt16? op2) { return op1 == op2; } public bool Inequality (UInt16? op1, UInt16? op2) { return op1 != op2; } public bool GreaterThan (UInt16? op1, UInt16? op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt16? op1, UInt16? op2) { return op1 >= op2; } public bool LessThan (UInt16? op1, UInt16? op2) { return op1 < op2; } public bool LessThanOrEqual (UInt16? op1, UInt16? op2) { return op1 <= op2; } } #endregion #region UInt32 private class NU32 : IOperable<UInt32?> { public UInt32? Addition (UInt32? op1, UInt32? op2) { return (op1 + op2); } public UInt32? Subtraction (UInt32? op1, UInt32? op2) { return (op1 - op2); } public UInt32? Multiply (UInt32? op1, UInt32? op2) { return (op1 * op2); } public UInt32? Division (UInt32? op1, UInt32? op2) { return (op1 / op2); } public UInt32? Modulus (UInt32? op1, UInt32? op2) { return (op1 % op2); } public UInt32? BitwiseAnd (UInt32? op1, UInt32? op2) { return (op1 & op2); } public UInt32? BitwiseOr (UInt32? op1, UInt32? op2) { return (op1 | op2); } public UInt32? ExclusiveOr (UInt32? op1, UInt32? op2) { return (op1 ^ op2); } public UInt32? UnaryNegation (UInt32? op) { throw new InvalidOperationException(); } public UInt32? OnesComplement (UInt32? op) { return (~op); } public bool Equality (UInt32? op1, UInt32? op2) { return op1 == op2; } public bool Inequality (UInt32? op1, UInt32? op2) { return op1 != op2; } public bool GreaterThan (UInt32? op1, UInt32? op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt32? op1, UInt32? op2) { return op1 >= op2; } public bool LessThan (UInt32? op1, UInt32? op2) { return op1 < op2; } public bool LessThanOrEqual (UInt32? op1, UInt32? op2) { return op1 <= op2; } } #endregion #region UInt64 private class NU64 : IOperable<UInt64?> { public UInt64? Addition (UInt64? op1, UInt64? op2) { return (op1 + op2); } public UInt64? Subtraction (UInt64? op1, UInt64? op2) { return (op1 - op2); } public UInt64? Multiply (UInt64? op1, UInt64? op2) { return (op1 * op2); } public UInt64? Division (UInt64? op1, UInt64? op2) { return (op1 / op2); } public UInt64? Modulus (UInt64? op1, UInt64? op2) { return (op1 % op2); } public UInt64? BitwiseAnd (UInt64? op1, UInt64? op2) { return (op1 & op2); } public UInt64? BitwiseOr (UInt64? op1, UInt64? op2) { return (op1 | op2); } public UInt64? ExclusiveOr (UInt64? op1, UInt64? op2) { return (op1 ^ op2); } public UInt64? UnaryNegation (UInt64? op) { throw new InvalidOperationException(); } public UInt64? OnesComplement (UInt64? op) { return (~op); } public bool Equality (UInt64? op1, UInt64? op2) { return op1 == op2; } public bool Inequality (UInt64? op1, UInt64? op2) { return op1 != op2; } public bool GreaterThan (UInt64? op1, UInt64? op2) { return op1 > op2; } public bool GreaterThanOrEqual(UInt64? op1, UInt64? op2) { return op1 >= op2; } public bool LessThan (UInt64? op1, UInt64? op2) { return op1 < op2; } public bool LessThanOrEqual (UInt64? op1, UInt64? op2) { return op1 <= op2; } } #endregion #region Boolean private class NB : IOperable<Boolean?> { public Boolean? Addition (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public Boolean? Subtraction (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public Boolean? Multiply (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public Boolean? Division (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public Boolean? Modulus (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public Boolean? BitwiseAnd (Boolean? op1, Boolean? op2) { return (op1 & op2); } public Boolean? BitwiseOr (Boolean? op1, Boolean? op2) { return (op1 | op2); } public Boolean? ExclusiveOr (Boolean? op1, Boolean? op2) { return (op1 ^ op2); } public Boolean? UnaryNegation (Boolean? op) { throw new InvalidOperationException(); } public Boolean? OnesComplement(Boolean? op) { return !op; } public bool Equality (Boolean? op1, Boolean? op2) { return op1 == op2; } public bool Inequality (Boolean? op1, Boolean? op2) { return op1 != op2; } public bool GreaterThan (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public bool LessThan (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (Boolean? op1, Boolean? op2) { throw new InvalidOperationException(); } } #endregion #region Char private class NC : IOperable<Char?> { public Char? Addition (Char? op1, Char? op2) { return (Char?)(op1 + op2); } public Char? Subtraction (Char? op1, Char? op2) { return (Char?)(op1 - op2); } public Char? Multiply (Char? op1, Char? op2) { return (Char?)(op1 * op2); } public Char? Division (Char? op1, Char? op2) { return (Char?)(op1 / op2); } public Char? Modulus (Char? op1, Char? op2) { return (Char?)(op1 % op2); } public Char? BitwiseAnd (Char? op1, Char? op2) { return (Char?)(op1 & op2); } public Char? BitwiseOr (Char? op1, Char? op2) { return (Char?)(op1 | op2); } public Char? ExclusiveOr (Char? op1, Char? op2) { return (Char?)(op1 ^ op2); } public Char? UnaryNegation (Char? op) { return (Char?)(-op); } public Char? OnesComplement (Char? op) { return (Char?)(~op); } public bool Equality (Char? op1, Char? op2) { return op1 == op2; } public bool Inequality (Char? op1, Char? op2) { return op1 != op2; } public bool GreaterThan (Char? op1, Char? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Char? op1, Char? op2) { return op1 >= op2; } public bool LessThan (Char? op1, Char? op2) { return op1 < op2; } public bool LessThanOrEqual (Char? op1, Char? op2) { return op1 <= op2; } } #endregion #region Single private class NR4 : IOperable<Single?> { public Single? Addition (Single? op1, Single? op2) { return (op1 + op2); } public Single? Subtraction (Single? op1, Single? op2) { return (op1 - op2); } public Single? Multiply (Single? op1, Single? op2) { return (op1 * op2); } public Single? Division (Single? op1, Single? op2) { return (op1 / op2); } public Single? Modulus (Single? op1, Single? op2) { return (op1 % op2); } public Single? BitwiseAnd (Single? op1, Single? op2) { throw new InvalidOperationException(); } public Single? BitwiseOr (Single? op1, Single? op2) { throw new InvalidOperationException(); } public Single? ExclusiveOr (Single? op1, Single? op2) { throw new InvalidOperationException(); } public Single? UnaryNegation (Single? op) { return (- op); } public Single? OnesComplement (Single? op) { throw new InvalidOperationException(); } public bool Equality (Single? op1, Single? op2) { return op1 == op2; } public bool Inequality (Single? op1, Single? op2) { return op1 != op2; } public bool GreaterThan (Single? op1, Single? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Single? op1, Single? op2) { return op1 >= op2; } public bool LessThan (Single? op1, Single? op2) { return op1 < op2; } public bool LessThanOrEqual (Single? op1, Single? op2) { return op1 <= op2; } } #endregion #region Double private class NR8 : IOperable<Double?> { public Double? Addition (Double? op1, Double? op2) { return (op1 + op2); } public Double? Subtraction (Double? op1, Double? op2) { return (op1 - op2); } public Double? Multiply (Double? op1, Double? op2) { return (op1 * op2); } public Double? Division (Double? op1, Double? op2) { return (op1 / op2); } public Double? Modulus (Double? op1, Double? op2) { return (op1 % op2); } public Double? BitwiseAnd (Double? op1, Double? op2) { throw new InvalidOperationException(); } public Double? BitwiseOr (Double? op1, Double? op2) { throw new InvalidOperationException(); } public Double? ExclusiveOr (Double? op1, Double? op2) { throw new InvalidOperationException(); } public Double? UnaryNegation (Double? op) { return (- op); } public Double? OnesComplement (Double? op) { throw new InvalidOperationException(); } public bool Equality (Double? op1, Double? op2) { return op1 == op2; } public bool Inequality (Double? op1, Double? op2) { return op1 != op2; } public bool GreaterThan (Double? op1, Double? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Double? op1, Double? op2) { return op1 >= op2; } public bool LessThan (Double? op1, Double? op2) { return op1 < op2; } public bool LessThanOrEqual (Double? op1, Double? op2) { return op1 <= op2; } } #endregion #region Decimal private class ND : IOperable<Decimal?> { public Decimal? Addition (Decimal? op1, Decimal? op2) { return (op1 + op2); } public Decimal? Subtraction (Decimal? op1, Decimal? op2) { return (op1 - op2); } public Decimal? Multiply (Decimal? op1, Decimal? op2) { return (op1 * op2); } public Decimal? Division (Decimal? op1, Decimal? op2) { return (op1 / op2); } public Decimal? Modulus (Decimal? op1, Decimal? op2) { return (op1 % op2); } public Decimal? BitwiseAnd (Decimal? op1, Decimal? op2) { throw new InvalidOperationException(); } public Decimal? BitwiseOr (Decimal? op1, Decimal? op2) { throw new InvalidOperationException(); } public Decimal? ExclusiveOr (Decimal? op1, Decimal? op2) { throw new InvalidOperationException(); } public Decimal? UnaryNegation (Decimal? op) { return (- op); } public Decimal? OnesComplement(Decimal? op) { throw new InvalidOperationException(); } public bool Equality (Decimal? op1, Decimal? op2) { return op1 == op2; } public bool Inequality (Decimal? op1, Decimal? op2) { return op1 != op2; } public bool GreaterThan (Decimal? op1, Decimal? op2) { return op1 > op2; } public bool GreaterThanOrEqual(Decimal? op1, Decimal? op2) { return op1 >= op2; } public bool LessThan (Decimal? op1, Decimal? op2) { return op1 < op2; } public bool LessThanOrEqual (Decimal? op1, Decimal? op2) { return op1 <= op2; } } #endregion #region DateTime private class NDT : IOperable<DateTime?> { public DateTime? Addition (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? Subtraction (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? Multiply (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? Division (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? Modulus (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? BitwiseAnd (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? BitwiseOr (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? ExclusiveOr (DateTime? op1, DateTime? op2) { throw new InvalidOperationException(); } public DateTime? UnaryNegation (DateTime? op) { throw new InvalidOperationException(); } public DateTime? OnesComplement(DateTime? op) { throw new InvalidOperationException(); } public bool Equality (DateTime? op1, DateTime? op2) { return op1 == op2; } public bool Inequality (DateTime? op1, DateTime? op2) { return op1 != op2; } public bool GreaterThan (DateTime? op1, DateTime? op2) { return op1 > op2; } public bool GreaterThanOrEqual (DateTime? op1, DateTime? op2) { return op1 >= op2; } public bool LessThan (DateTime? op1, DateTime? op2) { return op1 < op2; } public bool LessThanOrEqual (DateTime? op1, DateTime? op2) { return op1 <= op2; } } #endregion #region TimeSpan private class NTS : IOperable<TimeSpan?> { public TimeSpan? Addition (TimeSpan? op1, TimeSpan? op2) { return (op1 + op2); } public TimeSpan? Subtraction (TimeSpan? op1, TimeSpan? op2) { return (op1 - op2); } public TimeSpan? Multiply (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? Division (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? Modulus (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? BitwiseAnd (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? BitwiseOr (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? ExclusiveOr (TimeSpan? op1, TimeSpan? op2) { throw new InvalidOperationException(); } public TimeSpan? UnaryNegation (TimeSpan? op) { return (- op); } public TimeSpan? OnesComplement(TimeSpan? op) { throw new InvalidOperationException(); } public bool Equality (TimeSpan? op1, TimeSpan? op2) { return op1 == op2; } public bool Inequality (TimeSpan? op1, TimeSpan? op2) { return op1 != op2; } public bool GreaterThan (TimeSpan? op1, TimeSpan? op2) { return op1 > op2; } public bool GreaterThanOrEqual (TimeSpan? op1, TimeSpan? op2) { return op1 >= op2; } public bool LessThan (TimeSpan? op1, TimeSpan? op2) { return op1 < op2; } public bool LessThanOrEqual (TimeSpan? op1, TimeSpan? op2) { return op1 <= op2; } } #endregion #region Guid? private class NG : IOperable<Guid?> { public Guid? Addition (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? Subtraction (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? Multiply (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? Division (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? Modulus (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? BitwiseAnd (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? BitwiseOr (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? ExclusiveOr (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public Guid? UnaryNegation (Guid? op) { throw new InvalidOperationException(); } public Guid? OnesComplement (Guid? op) { throw new InvalidOperationException(); } public bool Equality (Guid? op1, Guid? op2) { return op1 == op2; } public bool Inequality (Guid? op1, Guid? op2) { return op1 != op2; } public bool GreaterThan (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual(Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public bool LessThan (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (Guid? op1, Guid? op2) { throw new InvalidOperationException(); } } #endregion #endregion #region Sql types. #region SqlString private class DBS : IOperable<SqlString> { public SqlString Addition (SqlString op1, SqlString op2) { return (op1 + op2); } public SqlString Subtraction (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString Multiply (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString Division (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString Modulus (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString BitwiseAnd (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString BitwiseOr (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString ExclusiveOr (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public SqlString UnaryNegation (SqlString op) { throw new InvalidOperationException(); } public SqlString OnesComplement(SqlString op) { throw new InvalidOperationException(); } public bool Equality (SqlString op1, SqlString op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlString op1, SqlString op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public bool LessThan (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (SqlString op1, SqlString op2) { throw new InvalidOperationException(); } } #endregion #region SqlByte private class DBU8 : IOperable<SqlByte> { public SqlByte Addition (SqlByte op1, SqlByte op2) { return (op1 + op2); } public SqlByte Subtraction (SqlByte op1, SqlByte op2) { return (op1 - op2); } public SqlByte Multiply (SqlByte op1, SqlByte op2) { return (op1 * op2); } public SqlByte Division (SqlByte op1, SqlByte op2) { return (op1 / op2); } public SqlByte Modulus (SqlByte op1, SqlByte op2) { return (op1 % op2); } public SqlByte BitwiseAnd (SqlByte op1, SqlByte op2) { return (op1 & op2); } public SqlByte BitwiseOr (SqlByte op1, SqlByte op2) { return (op1 | op2); } public SqlByte ExclusiveOr (SqlByte op1, SqlByte op2) { return (op1 ^ op2); } public SqlByte UnaryNegation (SqlByte op) { throw new InvalidOperationException(); } public SqlByte OnesComplement (SqlByte op) { return (~op); } public bool Equality (SqlByte op1, SqlByte op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlByte op1, SqlByte op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlByte op1, SqlByte op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlByte op1, SqlByte op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlByte op1, SqlByte op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlByte op1, SqlByte op2) { return (op1 <= op2).IsTrue; } } #endregion #region Int16 private class DBS16 : IOperable<SqlInt16> { public SqlInt16 Addition (SqlInt16 op1, SqlInt16 op2) { return (op1 + op2); } public SqlInt16 Subtraction (SqlInt16 op1, SqlInt16 op2) { return (op1 - op2); } public SqlInt16 Multiply (SqlInt16 op1, SqlInt16 op2) { return (op1 * op2); } public SqlInt16 Division (SqlInt16 op1, SqlInt16 op2) { return (op1 / op2); } public SqlInt16 Modulus (SqlInt16 op1, SqlInt16 op2) { return (op1 % op2); } public SqlInt16 BitwiseAnd (SqlInt16 op1, SqlInt16 op2) { return (op1 & op2); } public SqlInt16 BitwiseOr (SqlInt16 op1, SqlInt16 op2) { return (op1 | op2); } public SqlInt16 ExclusiveOr (SqlInt16 op1, SqlInt16 op2) { return (op1 ^ op2); } public SqlInt16 UnaryNegation (SqlInt16 op) { return (-op); } public SqlInt16 OnesComplement(SqlInt16 op) { return (~op); } public bool Equality (SqlInt16 op1, SqlInt16 op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlInt16 op1, SqlInt16 op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlInt16 op1, SqlInt16 op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlInt16 op1, SqlInt16 op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlInt16 op1, SqlInt16 op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlInt16 op1, SqlInt16 op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlInt32 private class DBS32 : IOperable<SqlInt32> { public SqlInt32 Addition (SqlInt32 op1, SqlInt32 op2) { return (op1 + op2); } public SqlInt32 Subtraction (SqlInt32 op1, SqlInt32 op2) { return (op1 - op2); } public SqlInt32 Multiply (SqlInt32 op1, SqlInt32 op2) { return (op1 * op2); } public SqlInt32 Division (SqlInt32 op1, SqlInt32 op2) { return (op1 / op2); } public SqlInt32 Modulus (SqlInt32 op1, SqlInt32 op2) { return (op1 % op2); } public SqlInt32 BitwiseAnd (SqlInt32 op1, SqlInt32 op2) { return (op1 & op2); } public SqlInt32 BitwiseOr (SqlInt32 op1, SqlInt32 op2) { return (op1 | op2); } public SqlInt32 ExclusiveOr (SqlInt32 op1, SqlInt32 op2) { return (op1 ^ op2); } public SqlInt32 UnaryNegation (SqlInt32 op) { return (-op); } public SqlInt32 OnesComplement(SqlInt32 op) { return (~op); } public bool Equality (SqlInt32 op1, SqlInt32 op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlInt32 op1, SqlInt32 op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlInt32 op1, SqlInt32 op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlInt32 op1, SqlInt32 op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlInt32 op1, SqlInt32 op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlInt32 op1, SqlInt32 op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlInt64 private class DBS64 : IOperable<SqlInt64> { public SqlInt64 Addition (SqlInt64 op1, SqlInt64 op2) { return (op1 + op2); } public SqlInt64 Subtraction (SqlInt64 op1, SqlInt64 op2) { return (op1 - op2); } public SqlInt64 Multiply (SqlInt64 op1, SqlInt64 op2) { return (op1 * op2); } public SqlInt64 Division (SqlInt64 op1, SqlInt64 op2) { return (op1 / op2); } public SqlInt64 Modulus (SqlInt64 op1, SqlInt64 op2) { return (op1 % op2); } public SqlInt64 BitwiseAnd (SqlInt64 op1, SqlInt64 op2) { return (op1 & op2); } public SqlInt64 BitwiseOr (SqlInt64 op1, SqlInt64 op2) { return (op1 | op2); } public SqlInt64 ExclusiveOr (SqlInt64 op1, SqlInt64 op2) { return (op1 ^ op2); } public SqlInt64 UnaryNegation (SqlInt64 op) { return (-op); } public SqlInt64 OnesComplement(SqlInt64 op) { return (~op); } public bool Equality (SqlInt64 op1, SqlInt64 op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlInt64 op1, SqlInt64 op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlInt64 op1, SqlInt64 op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlInt64 op1, SqlInt64 op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlInt64 op1, SqlInt64 op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlInt64 op1, SqlInt64 op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlBoolean private class DBB : IOperable<SqlBoolean> { public SqlBoolean Addition (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public SqlBoolean Subtraction (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public SqlBoolean Multiply (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public SqlBoolean Division (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public SqlBoolean Modulus (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public SqlBoolean BitwiseAnd (SqlBoolean op1, SqlBoolean op2) { return (op1 & op2); } public SqlBoolean BitwiseOr (SqlBoolean op1, SqlBoolean op2) { return (op1 | op2); } public SqlBoolean ExclusiveOr (SqlBoolean op1, SqlBoolean op2) { return (op1 ^ op2); } public SqlBoolean UnaryNegation (SqlBoolean op) { throw new InvalidOperationException(); } public SqlBoolean OnesComplement(SqlBoolean op) { return !op; } public bool Equality (SqlBoolean op1, SqlBoolean op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlBoolean op1, SqlBoolean op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public bool GreaterThanOrEqual (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public bool LessThan (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } public bool LessThanOrEqual (SqlBoolean op1, SqlBoolean op2) { throw new InvalidOperationException(); } } #endregion #region SqlSingle private class DBR4 : IOperable<SqlSingle> { public SqlSingle Addition (SqlSingle op1, SqlSingle op2) { return (op1 + op2); } public SqlSingle Subtraction (SqlSingle op1, SqlSingle op2) { return (op1 - op2); } public SqlSingle Multiply (SqlSingle op1, SqlSingle op2) { return (op1 * op2); } public SqlSingle Division (SqlSingle op1, SqlSingle op2) { return (op1 / op2); } public SqlSingle Modulus (SqlSingle op1, SqlSingle op2) { throw new InvalidOperationException(); } public SqlSingle BitwiseAnd (SqlSingle op1, SqlSingle op2) { throw new InvalidOperationException(); } public SqlSingle BitwiseOr (SqlSingle op1, SqlSingle op2) { throw new InvalidOperationException(); } public SqlSingle ExclusiveOr (SqlSingle op1, SqlSingle op2) { throw new InvalidOperationException(); } public SqlSingle UnaryNegation (SqlSingle op) { return (-op); } public SqlSingle OnesComplement(SqlSingle op) { throw new InvalidOperationException(); } public bool Equality (SqlSingle op1, SqlSingle op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlSingle op1, SqlSingle op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlSingle op1, SqlSingle op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual (SqlSingle op1, SqlSingle op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlSingle op1, SqlSingle op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlSingle op1, SqlSingle op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlDouble private class DBR8 : IOperable<SqlDouble> { public SqlDouble Addition (SqlDouble op1, SqlDouble op2) { return (op1 + op2); } public SqlDouble Subtraction (SqlDouble op1, SqlDouble op2) { return (op1 - op2); } public SqlDouble Multiply (SqlDouble op1, SqlDouble op2) { return (op1 * op2); } public SqlDouble Division (SqlDouble op1, SqlDouble op2) { return (op1 / op2); } public SqlDouble Modulus (SqlDouble op1, SqlDouble op2) { throw new InvalidOperationException(); } public SqlDouble BitwiseAnd (SqlDouble op1, SqlDouble op2) { throw new InvalidOperationException(); } public SqlDouble BitwiseOr (SqlDouble op1, SqlDouble op2) { throw new InvalidOperationException(); } public SqlDouble ExclusiveOr (SqlDouble op1, SqlDouble op2) { throw new InvalidOperationException(); } public SqlDouble UnaryNegation (SqlDouble op) { return (-op); } public SqlDouble OnesComplement(SqlDouble op) { throw new InvalidOperationException(); } public bool Equality (SqlDouble op1, SqlDouble op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlDouble op1, SqlDouble op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlDouble op1, SqlDouble op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual (SqlDouble op1, SqlDouble op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlDouble op1, SqlDouble op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlDouble op1, SqlDouble op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlDecimal private class DBD : IOperable<SqlDecimal> { public SqlDecimal Addition (SqlDecimal op1, SqlDecimal op2) { return (op1 + op2); } public SqlDecimal Subtraction (SqlDecimal op1, SqlDecimal op2) { return (op1 - op2); } public SqlDecimal Multiply (SqlDecimal op1, SqlDecimal op2) { return (op1 * op2); } public SqlDecimal Division (SqlDecimal op1, SqlDecimal op2) { return (op1 / op2); } public SqlDecimal Modulus (SqlDecimal op1, SqlDecimal op2) { throw new InvalidOperationException(); } public SqlDecimal BitwiseAnd (SqlDecimal op1, SqlDecimal op2) { throw new InvalidOperationException(); } public SqlDecimal BitwiseOr (SqlDecimal op1, SqlDecimal op2) { throw new InvalidOperationException(); } public SqlDecimal ExclusiveOr (SqlDecimal op1, SqlDecimal op2) { throw new InvalidOperationException(); } public SqlDecimal UnaryNegation (SqlDecimal op) { return (-op); } public SqlDecimal OnesComplement(SqlDecimal op) { throw new InvalidOperationException(); } public bool Equality (SqlDecimal op1, SqlDecimal op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlDecimal op1, SqlDecimal op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlDecimal op1, SqlDecimal op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual (SqlDecimal op1, SqlDecimal op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlDecimal op1, SqlDecimal op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlDecimal op1, SqlDecimal op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlMoney private class DBM : IOperable<SqlMoney> { public SqlMoney Addition (SqlMoney op1, SqlMoney op2) { return (op1 + op2); } public SqlMoney Subtraction (SqlMoney op1, SqlMoney op2) { return (op1 - op2); } public SqlMoney Multiply (SqlMoney op1, SqlMoney op2) { return (op1 * op2); } public SqlMoney Division (SqlMoney op1, SqlMoney op2) { return (op1 / op2); } public SqlMoney Modulus (SqlMoney op1, SqlMoney op2) { throw new InvalidOperationException(); } public SqlMoney BitwiseAnd (SqlMoney op1, SqlMoney op2) { throw new InvalidOperationException(); } public SqlMoney BitwiseOr (SqlMoney op1, SqlMoney op2) { throw new InvalidOperationException(); } public SqlMoney ExclusiveOr (SqlMoney op1, SqlMoney op2) { throw new InvalidOperationException(); } public SqlMoney UnaryNegation (SqlMoney op) { return (-op); } public SqlMoney OnesComplement(SqlMoney op) { throw new InvalidOperationException(); } public bool Equality (SqlMoney op1, SqlMoney op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlMoney op1, SqlMoney op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlMoney op1, SqlMoney op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlMoney op1, SqlMoney op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlMoney op1, SqlMoney op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlMoney op1, SqlMoney op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlDateTime private class DBDT : IOperable<SqlDateTime> { public SqlDateTime Addition (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime Subtraction (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime Multiply (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime Division (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime Modulus (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime BitwiseAnd (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime BitwiseOr (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime ExclusiveOr (SqlDateTime op1, SqlDateTime op2) { throw new InvalidOperationException(); } public SqlDateTime UnaryNegation (SqlDateTime op) { throw new InvalidOperationException(); } public SqlDateTime OnesComplement(SqlDateTime op) { throw new InvalidOperationException(); } public bool Equality (SqlDateTime op1, SqlDateTime op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlDateTime op1, SqlDateTime op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlDateTime op1, SqlDateTime op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual (SqlDateTime op1, SqlDateTime op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlDateTime op1, SqlDateTime op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlDateTime op1, SqlDateTime op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlBinary private class DBBin : IOperable<SqlBinary> { public SqlBinary Addition (SqlBinary op1, SqlBinary op2) { return (op1 + op2); } public SqlBinary Subtraction (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary Multiply (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary Division (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary Modulus (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary BitwiseAnd (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary BitwiseOr (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary ExclusiveOr (SqlBinary op1, SqlBinary op2) { throw new InvalidOperationException(); } public SqlBinary UnaryNegation (SqlBinary op) { throw new InvalidOperationException(); } public SqlBinary OnesComplement(SqlBinary op) { throw new InvalidOperationException(); } public bool Equality (SqlBinary op1, SqlBinary op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlBinary op1, SqlBinary op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlBinary op1, SqlBinary op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual (SqlBinary op1, SqlBinary op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlBinary op1, SqlBinary op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlBinary op1, SqlBinary op2) { return (op1 <= op2).IsTrue; } } #endregion #region SqlGuid private class DBG : IOperable<SqlGuid> { public SqlGuid Addition (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid Subtraction (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid Multiply (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid Division (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid Modulus (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid BitwiseAnd (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid BitwiseOr (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid ExclusiveOr (SqlGuid op1, SqlGuid op2) { throw new InvalidOperationException(); } public SqlGuid UnaryNegation (SqlGuid op) { throw new InvalidOperationException(); } public SqlGuid OnesComplement (SqlGuid op) { throw new InvalidOperationException(); } public bool Equality (SqlGuid op1, SqlGuid op2) { return (op1 == op2).IsTrue; } public bool Inequality (SqlGuid op1, SqlGuid op2) { return (op1 != op2).IsTrue; } public bool GreaterThan (SqlGuid op1, SqlGuid op2) { return (op1 > op2).IsTrue; } public bool GreaterThanOrEqual(SqlGuid op1, SqlGuid op2) { return (op1 >= op2).IsTrue; } public bool LessThan (SqlGuid op1, SqlGuid op2) { return (op1 < op2).IsTrue; } public bool LessThanOrEqual (SqlGuid op1, SqlGuid op2) { return (op1 <= op2).IsTrue; } } #endregion #endregion } public static class Operator { public static T Addition <T>(T a, T b) { return Operator<T>.Op.Addition (a, b); } public static T Subtraction <T>(T a, T b) { return Operator<T>.Op.Subtraction (a, b); } public static T Multiply <T>(T a, T b) { return Operator<T>.Op.Multiply (a, b); } public static T Division <T>(T a, T b) { return Operator<T>.Op.Division (a, b); } public static T Modulus <T>(T a, T b) { return Operator<T>.Op.Modulus (a, b); } public static T BitwiseAnd <T>(T a, T b) { return Operator<T>.Op.BitwiseAnd (a, b); } public static T BitwiseOr <T>(T a, T b) { return Operator<T>.Op.BitwiseOr (a, b); } public static T ExclusiveOr <T>(T a, T b) { return Operator<T>.Op.ExclusiveOr (a, b); } public static T UnaryNegation <T>(T a) { return Operator<T>.Op.UnaryNegation (a); } public static T OnesComplement <T>(T a) { return Operator<T>.Op.OnesComplement (a); } public static bool Equality <T>(T a, T b) { return Operator<T>.Op.Equality (a, b); } public static bool Inequality <T>(T a, T b) { return Operator<T>.Op.Inequality (a, b); } public static bool GreaterThan <T>(T a, T b) { return Operator<T>.Op.GreaterThan (a, b); } public static bool GreaterThanOrEqual<T>(T a, T b) { return Operator<T>.Op.GreaterThanOrEqual(a, b); } public static bool LessThan <T>(T a, T b) { return Operator<T>.Op.LessThan (a, b); } public static bool LessThanOrEqual <T>(T a, T b) { return Operator<T>.Op.LessThanOrEqual (a, b); } } }