SqlBoolean.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2015 Deveel
// 
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
// 
//        http://www.apache.org/licenses/LICENSE-2.0
// 
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
//

using System;

using Deveel.Data.Serialization;

namespace Deveel.Data.Sql.Objects {
    [Serializable]
    public struct SqlBoolean : ISqlObject, IEquatable<SqlBoolean>, IComparable<SqlBoolean>, IConvertible, ISerializable {
        private readonly byte? value;

        public static readonly SqlBoolean True = new SqlBoolean(1);

        public static readonly SqlBoolean False = new SqlBoolean(0);

        public static readonly SqlBoolean Null = new SqlBoolean((byte?)null);

        public SqlBoolean(byte value)
            : this() {
            if (value != 0 &&
                value != 1)
                throw new ArgumentOutOfRangeException("value");

            this.value = value;
        }

        public SqlBoolean(bool value)
            : this((byte)(value ? 1 : 0)) {
        }

        private SqlBoolean(byte? value)
            : this() {
            this.value = value;
        }

        private SqlBoolean(ObjectData data)
            : this() {
            if (data.HasValue("Value"))
                value = data.GetByte("Value");
        }

        int IComparable.CompareTo(object obj) {
            if (!(obj is ISqlObject))
                throw new ArgumentException();

            return CompareTo((ISqlObject) obj);
        }

        void ISerializable.GetData(SerializeData data) {
            if (value != null)
                data.SetValue("Value", value.Value);
        }

        public int CompareTo(ISqlObject other) {
            if (other is SqlNull) {
                if (IsNull)
                    return 0;
                return 1;
            }

            SqlBoolean otherBoolean;
            if (other is SqlNumber) {
                var num = (SqlNumber) other;
                if (num.IsNull) {
                    otherBoolean = Null;
                } else if (num == SqlNumber.One) {
                    otherBoolean = True;
                } else if (num == SqlNumber.Zero) {
                    otherBoolean = False;
                } else {
                    throw new ArgumentOutOfRangeException("other", "The given numeric value is out of range for a comparison with SQL BOOLEAN.");
                }
            } else if (other is SqlBoolean) {
                otherBoolean = (SqlBoolean) other;
            } else {
                throw new ArgumentException(String.Format("Object of type {0} cannot be compared to SQL BOOLEAN", other.GetType().FullName));
            }

            return CompareTo(otherBoolean);
        }

        public bool IsNull {
            get { return value == null; }
        }

        public bool IsComparableTo(ISqlObject other) {
            if (other is SqlBoolean || other is SqlNull)
                return true;

            if (other is SqlNumber) {
                var num = (SqlNumber) other;
                return num == SqlNumber.Zero || num == SqlNumber.One;
            }

            return false;
        }

        public override bool Equals(object obj) {
            if (obj is SqlNull && IsNull)
                return true;

            if (!(obj is SqlBoolean))
                return false;

            return Equals((SqlBoolean) obj);
        }

        public bool Equals(SqlBoolean other) {
            if (IsNull && other.IsNull)
                return true;
            if (IsNull && !other.IsNull)
                return false;
            if (!IsNull && other.IsNull)
                return false;

            return value.Equals(other.value);
        }

        public SqlBoolean Not() {
            if (value == null)
                return Null;

            if (value == 1)
                return False;
            if (value == 0)
                return True;

            throw new InvalidOperationException();
        }

        public SqlBoolean Or(SqlBoolean other) {
            if (value == null ||
                other.IsNull)
                return Null;

            if (value == 1 || other.value == 1)
                return True;

            return False;
        }

        public SqlBoolean And(SqlBoolean other) {
            if (value == null ||
                other.IsNull)
                return Null;

            if (value == 1 && other.value == 1)
                return True;

            return False;           
        }

        public SqlBoolean XOr(SqlBoolean other) {
            if (value == null ||
                other.IsNull)
                return Null;

            if (value == 1 && other.value == 0)
                return True;
            if (value == 0 && other.value == 1)
                return True;

            return False;
        }

        public override int GetHashCode() {
            return value == null ? 0 : value.Value.GetHashCode();
        }

        TypeCode IConvertible.GetTypeCode() {
            return TypeCode.Boolean;
        }

        bool IConvertible.ToBoolean(IFormatProvider provider) {
            return this;
        }

        char IConvertible.ToChar(IFormatProvider provider) {
            throw new InvalidCastException();
        }

        sbyte IConvertible.ToSByte(IFormatProvider provider) {
            return (sbyte) (this as IConvertible).ToInt32(provider);
        }

        byte IConvertible.ToByte(IFormatProvider provider) {
            if (value == null)
                throw new NullReferenceException();

            return value.Value;
        }

        short IConvertible.ToInt16(IFormatProvider provider) {
            return (short) (this as IConvertible).ToInt32(provider);
        }

        ushort IConvertible.ToUInt16(IFormatProvider provider) {
            return (ushort) (this as IConvertible).ToInt32(provider);
        }

        int IConvertible.ToInt32(IFormatProvider provider) {
            if (value == null)
                throw new NullReferenceException();

            return value.Value;
        }

        uint IConvertible.ToUInt32(IFormatProvider provider) {
            return (uint) (this as IConvertible).ToInt32(provider);
        }

        long IConvertible.ToInt64(IFormatProvider provider) {
            return (this as IConvertible).ToInt64(provider);
        }

        ulong IConvertible.ToUInt64(IFormatProvider provider) {
            return (this as IConvertible).ToUInt64(provider);
        }

        float IConvertible.ToSingle(IFormatProvider provider) {
            return (this as IConvertible).ToInt32(provider);
        }

        double IConvertible.ToDouble(IFormatProvider provider) {
            return (this as IConvertible).ToInt32(provider);
        }

        decimal IConvertible.ToDecimal(IFormatProvider provider) {
            return (this as IConvertible).ToInt32(provider);
        }

        DateTime IConvertible.ToDateTime(IFormatProvider provider) {
            throw new InvalidCastException();
        }

        string IConvertible.ToString(IFormatProvider provider) {
            return ToString();
        }

        object IConvertible.ToType(Type conversionType, IFormatProvider provider) {
            if (conversionType == typeof (bool))
                return (bool) this;

            throw new InvalidCastException(String.Format("Cannot convert a SQL BOOLEAN to {0}", conversionType.FullName));
        }

        public int CompareTo(SqlBoolean other) {
            if (other.IsNull && IsNull)
                return 0;

            if (IsNull && !other.IsNull)
                return -1;
            if (!IsNull && other.IsNull)
                return 1;

            return value.Value.CompareTo(other.value.Value);
        }

        public static SqlBoolean operator ==(SqlBoolean a, SqlBoolean b) {
            return a.Equals(b);
        }

        public static SqlBoolean operator !=(SqlBoolean a, SqlBoolean b) {
            return !(a == b);
        }

        public static SqlBoolean operator ==(SqlBoolean a, ISqlObject b) {
            return a.Equals(b);
        }

        public static SqlBoolean operator !=(SqlBoolean a, ISqlObject b) {
            return !(a == b);
        }

        public static SqlBoolean operator &(SqlBoolean a, SqlBoolean b) {
            return a.And(b);
        }

        public static SqlBoolean operator |(SqlBoolean a, SqlBoolean b) {
            return a.Or(b);
        }

        public static SqlBoolean operator ^(SqlBoolean a, SqlBoolean b) {
            return a.XOr(b);
        }

        public static SqlBoolean operator !(SqlBoolean a) {
            return a.Not();
        }

        public static implicit operator bool(SqlBoolean value) {
            if (value.IsNull)
                throw new InvalidCastException();

            return value.value == 1;
        }

        public static implicit operator SqlBoolean(bool value) {
            return new SqlBoolean(value);
        }

        public static SqlBoolean Parse(string s) {
            if (String.IsNullOrEmpty(s))
                throw new ArgumentNullException("s");

            SqlBoolean value;
            if (!TryParse(s, out value))
                throw new FormatException();

            return value;
        }

        public static bool TryParse(string s, out SqlBoolean value) {
            value = new SqlBoolean();

            if (String.IsNullOrEmpty(s))
                return false;

            if (String.Equals(s, "true", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(s, "1")) {
                value = True;
                return true;
            }
            if (String.Equals(s, "false", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(s, "0")) {
                value = False;
                return true;
            }

            return false;
        }

        public override string ToString() {
            if (value == null)
                return "NULL";
            if (value == 1)
                return "true";
            if (value == 0)
                return "false";

            throw new InvalidOperationException("Should never happen!");
        }
    }
}