Invercargill/src/lib/Promotions/Numbers/Implementations.vala

namespace Invercargill {

    public class SignedNativeIntegers : Numbers<int, SignedNativeIntegers> {
        protected override SignedNativeIntegers rewrap(Enumerable<int> enumerable) {
            return (SignedNativeIntegers)new SignedNativeIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int));
        }
        protected override int convert(uint i) {
            return (int)i;
        }
        protected override bool greater_than(int a, int b) {
            return a > b;
        }
        protected override bool less_than(int a, int b) {
            return a < b;
        }
        protected override bool equal_to(int a, int b) {
            return a == b;
        }
        protected override int add(int a, int b) {
            return a + b;
        }
        protected override int subtract(int a, int b) {
            return a - b;
        }
        protected override int multiply(int a, int b) {
            return a * b;
        }
        protected override int divide(int a, int b) {
            return a / b;
        }
        protected override int zero() {
            return 0;
        }        
    }

    public class UnsignedNativeIntegers : Numbers<uint, UnsignedNativeIntegers> {
        protected override UnsignedNativeIntegers rewrap(Enumerable<uint> enumerable) {
            return (UnsignedNativeIntegers)new UnsignedNativeIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint));
        }
        protected override uint convert(uint i) {
            return i;
        }
        protected override bool greater_than(uint a, uint b) {
            return a > b;
        }
        protected override bool less_than(uint a, uint b) {
            return a < b;
        }
        protected override bool equal_to(uint a, uint b) {
            return a == b;
        }
        protected override uint add(uint a, uint b) {
            return a + b;
        }
        protected override uint subtract(uint a, uint b) {
            return a - b;
        }
        protected override uint multiply(uint a, uint b) {
            return a * b;
        }
        protected override uint divide(uint a, uint b) {
            return a / b;
        }
        protected override uint zero() {
            return 0;
        }      
    }

    public class Signed8BitIntegers : Numbers<int8, Signed8BitIntegers> {
        protected override Signed8BitIntegers rewrap(Enumerable<int8> enumerable) {
            return (Signed8BitIntegers)new Signed8BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int8));
        }
        protected override int8 convert(uint i) {
            return (int8)i;
        }
        protected override bool greater_than(int8 a, int8 b) {
            return a > b;
        }
        protected override bool less_than(int8 a, int8 b) {
            return a < b;
        }
        protected override bool equal_to(int8 a, int8 b) {
            return a == b;
        }
        protected override int8 add(int8 a, int8 b) {
            return a + b;
        }
        protected override int8 subtract(int8 a, int8 b) {
            return a - b;
        }
        protected override int8 multiply(int8 a, int8 b) {
            return a * b;
        }
        protected override int8 divide(int8 a, int8 b) {
            return a / b;
        }
        protected override int8 zero() {
            return 0;
        }      
    }

    public class Unsigned8BitIntegers : Numbers<uint8, Unsigned8BitIntegers> {
        protected override Unsigned8BitIntegers rewrap(Enumerable<uint8> enumerable) {
            return (Unsigned8BitIntegers)new Unsigned8BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint8));
        }
        protected override uint8 convert(uint i) {
            return (uint8)i;
        }
        protected override bool greater_than(uint8 a, uint8 b) {
            return a > b;
        }
        protected override bool less_than(uint8 a, uint8 b) {
            return a < b;
        }
        protected override bool equal_to(uint8 a, uint8 b) {
            return a == b;
        }
        protected override uint8 add(uint8 a, uint8 b) {
            return a + b;
        }
        protected override uint8 subtract(uint8 a, uint8 b) {
            return a - b;
        }
        protected override uint8 multiply(uint8 a, uint8 b) {
            return a * b;
        }
        protected override uint8 divide(uint8 a, uint8 b) {
            return a / b;
        }
        protected override uint8 zero() {
            return 0;
        }      
    }

    public class Signed16BitIntegers : Numbers<int16, Signed16BitIntegers> {
        protected override Signed16BitIntegers rewrap(Enumerable<int16> enumerable) {
            return (Signed16BitIntegers)new Signed16BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int16));
        }
        protected override int16 convert(uint i) {
            return (int16)i;
        }
        protected override bool greater_than(int16 a, int16 b) {
            return a > b;
        }
        protected override bool less_than(int16 a, int16 b) {
            return a < b;
        }
        protected override bool equal_to(int16 a, int16 b) {
            return a == b;
        }
        protected override int16 add(int16 a, int16 b) {
            return a + b;
        }
        protected override int16 subtract(int16 a, int16 b) {
            return a - b;
        }
        protected override int16 multiply(int16 a, int16 b) {
            return a * b;
        }
        protected override int16 divide(int16 a, int16 b) {
            return a / b;
        }
        protected override int16 zero() {
            return 0;
        }      
    }

    public class Unsigned16BitIntegers : Numbers<uint16, Unsigned16BitIntegers> {
        protected override Unsigned16BitIntegers rewrap(Enumerable<uint16> enumerable) {
            return (Unsigned16BitIntegers)new Unsigned16BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint16));
        }
        protected override uint16 convert(uint i) {
            return (uint16)i;
        }
        protected override bool greater_than(uint16 a, uint16 b) {
            return a > b;
        }
        protected override bool less_than(uint16 a, uint16 b) {
            return a < b;
        }
        protected override bool equal_to(uint16 a, uint16 b) {
            return a == b;
        }
        protected override uint16 add(uint16 a, uint16 b) {
            return a + b;
        }
        protected override uint16 subtract(uint16 a, uint16 b) {
            return a - b;
        }
        protected override uint16 multiply(uint16 a, uint16 b) {
            return a * b;
        }
        protected override uint16 divide(uint16 a, uint16 b) {
            return a / b;
        }
        protected override uint16 zero() {
            return 0;
        }      
    }

    public class Signed32BitIntegers : Numbers<int32, Signed32BitIntegers> {
        protected override Signed32BitIntegers rewrap(Enumerable<int32> enumerable) {
            return (Signed32BitIntegers)new Signed32BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int32));
        }
        protected override int32 convert(uint i) {
            return (int32)i;
        }
        protected override bool greater_than(int32 a, int32 b) {
            return a > b;
        }
        protected override bool less_than(int32 a, int32 b) {
            return a < b;
        }
        protected override bool equal_to(int32 a, int32 b) {
            return a == b;
        }
        protected override int32 add(int32 a, int32 b) {
            return a + b;
        }
        protected override int32 subtract(int32 a, int32 b) {
            return a - b;
        }
        protected override int32 multiply(int32 a, int32 b) {
            return a * b;
        }
        protected override int32 divide(int32 a, int32 b) {
            return a / b;
        }
        protected override int32 zero() {
            return 0;
        }      
    }

    public class Unsigned32BitIntegers : Numbers<uint32, Unsigned32BitIntegers> {
        protected override Unsigned32BitIntegers rewrap(Enumerable<uint32> enumerable) {
            return (Unsigned32BitIntegers)new Unsigned32BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint32));
        }
        protected override uint32 convert(uint i) {
            return (uint32)i;
        }
        protected override bool greater_than(uint32 a, uint32 b) {
            return a > b;
        }
        protected override bool less_than(uint32 a, uint32 b) {
            return a < b;
        }
        protected override bool equal_to(uint32 a, uint32 b) {
            return a == b;
        }
        protected override uint32 add(uint32 a, uint32 b) {
            return a + b;
        }
        protected override uint32 subtract(uint32 a, uint32 b) {
            return a - b;
        }
        protected override uint32 multiply(uint32 a, uint32 b) {
            return a * b;
        }
        protected override uint32 divide(uint32 a, uint32 b) {
            return a / b;
        }
        protected override uint32 zero() {
            return 0;
        }      
    }

    public class Signed64BitIntegers : Numbers<int64?, Signed64BitIntegers> {
        protected override Signed64BitIntegers rewrap(Enumerable<int64?> enumerable) {
            return (Signed64BitIntegers)new Signed64BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int64?));
        }
        protected override int64? convert(uint i) {
            return (int64)i;
        }
        protected override bool greater_than(int64? a, int64? b) {
            return a > b;
        }
        protected override bool less_than(int64? a, int64? b) {
            return a < b;
        }
        protected override bool equal_to(int64? a, int64? b) {
            return a == b;
        }
        protected override int64? add(int64? a, int64? b) {
            return a + b;
        }
        protected override int64? subtract(int64? a, int64? b) {
            return a - b;
        }
        protected override int64? multiply(int64? a, int64? b) {
            return a * b;
        }
        protected override int64? divide(int64? a, int64? b) {
            return a / b;
        }
        protected override int64? zero() {
            return 0;
        }      
    }

    public class Unsigned64BitIntegers : Numbers<uint64?, Unsigned64BitIntegers> {
        protected override Unsigned64BitIntegers rewrap(Enumerable<uint64?> enumerable) {
            return (Unsigned64BitIntegers)new Unsigned64BitIntegers().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint64?));
        }
        protected override uint64? convert(uint i) {
            return (uint64)i;
        }
        protected override bool greater_than(uint64? a, uint64? b) {
            return a > b;
        }
        protected override bool less_than(uint64? a, uint64? b) {
            return a < b;
        }
        protected override bool equal_to(uint64? a, uint64? b) {
            return a == b;
        }
        protected override uint64? add(uint64? a, uint64? b) {
            return a + b;
        }
        protected override uint64? subtract(uint64? a, uint64? b) {
            return a - b;
        }
        protected override uint64? multiply(uint64? a, uint64? b) {
            return a * b;
        }
        protected override uint64? divide(uint64? a, uint64? b) {
            return a / b;
        }
        protected override uint64? zero() {
            return 0;
        }      
    }

    public class Doubles : Numbers<double?, Doubles> {
        protected override Doubles rewrap(Enumerable<double?> enumerable) {
            return (Doubles)new Doubles().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(double?));
        }
        protected override double? convert(uint i) {
            return (double?)i;
        }
        protected override bool greater_than(double? a, double? b) {
            return a > b;
        }
        protected override bool less_than(double? a, double? b) {
            return a < b;
        }
        protected override bool equal_to(double? a, double? b) {
            return a == b;
        }
        protected override double? add(double? a, double? b) {
            return a + b;
        }
        protected override double? subtract(double? a, double? b) {
            return a - b;
        }
        protected override double? multiply(double? a, double? b) {
            return a * b;
        }
        protected override double? divide(double? a, double? b) {
            return a / b;
        }
        protected override double? zero() {
            return 0;
        }      
    }

    public class Floats : Numbers<float?, Floats> {
        protected override Floats rewrap(Enumerable<float?> enumerable) {
            return (Floats)new Floats().wrap(enumerable);
        }
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(float?));
        }
        protected override float? convert(uint i) {
            return (float?)i;
        }
        protected override bool greater_than(float? a, float? b) {
            return a > b;
        }
        protected override bool less_than(float? a, float? b) {
            return a < b;
        }
        protected override bool equal_to(float? a, float? b) {
            return a == b;
        }
        protected override float? add(float? a, float? b) {
            return a + b;
        }
        protected override float? subtract(float? a, float? b) {
            return a - b;
        }
        protected override float? multiply(float? a, float? b) {
            return a * b;
        }
        protected override float? divide(float? a, float? b) {
            return a / b;
        }
        protected override float? zero() {
            return 0;
        }      
    }

}