Mercurial > pub > bltoolkit
diff Source/Common/Operator.cs @ 0:f990fcb411a9
Копия текущей версии из github
| author | cin |
|---|---|
| date | Thu, 27 Mar 2014 21:46:09 +0400 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Source/Common/Operator.cs Thu Mar 27 21:46:09 2014 +0400 @@ -0,0 +1,1405 @@ +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); } + } +}