include/nullable.h

Go to the documentation of this file.

// Copyright (C) 2009-2011 by Konrad Rosenbaum <konrad@silmor.de>
// protected under the GNU LGPL version 3 or at your option any newer.
// See COPYING.LGPL file that comes with this distribution.
//


#ifndef WOLF_NULLABLE_H
#define WOLF_NULLABLE_H

class NullValue
{
        public: 
                NullValue(){} 
                NullValue(const NullValue&){}
                
//              operator void*()const{return (void*)0;}
                template<typename T> operator T*()const{return (T*)0;}
                
                bool operator==(const NullValue&)const{return true;}
                bool operator!=(const NullValue&)const{return false;}
                
                template<typename T>bool operator==(const T*p)const{return p==0;}
                template<typename T>bool operator!=(const T*p)const{return p!=0;}
};

const NullValue nullval;

template<class T>class Nullable
{
        public:
                Nullable():isnull(true),elem(){}
                Nullable(const NullValue&):isnull(true),elem(){}
                Nullable(const T&t):isnull(false),elem(t){}
                Nullable(const Nullable<T>&t):isnull(t.isnull),elem(t.elem){}
                
                Nullable<T>& operator=(const T&t){isnull=false;elem=t;return *this;}
                Nullable<T>& operator=(const Nullable<T>&t){isnull=t.isnull;elem=t.elem;return *this;}
                
                bool isNull()const{return isnull;}
                
                operator T()const{if(isnull)return T();else return elem;}
                
                T& value(){return elem;}
                T value(const T&defaultval=T())const{if(isnull)return defaultval;else return elem;}
                
                bool operator==(const T&t)const{if(isnull)return false;else return elem == t;}
                bool operator!=(const T&t)const{if(isnull)return true;else return elem != t;}

                bool operator==(const Nullable<T>&t)const{
                        if(isnull != t.isnull)return false;
                        if(isnull)return true;
                        else return elem == t.elem;}
                bool operator!=(const Nullable<T>&t)const{
                        if(isnull != t.isnull)return true;
                        if(isnull)return false;
                        else return elem != t.elem;}
                
                bool operator==(const NullValue&)const{return isnull;}
                bool operator!=(const NullValue&)const{return !isnull;}
        private:
                bool isnull;
                T elem;
};

#include<QString>
#include<QMetaType>
//convenience wrappers
Q_DECLARE_METATYPE(NullValue);
Q_DECLARE_METATYPE(Nullable<bool>)
Q_DECLARE_METATYPE(Nullable<qint32>)
Q_DECLARE_METATYPE(Nullable<qint64>)
Q_DECLARE_METATYPE(Nullable<quint32>)
Q_DECLARE_METATYPE(Nullable<quint64>)
Q_DECLARE_METATYPE(Nullable<QString>)
Q_DECLARE_METATYPE(Nullable<QByteArray>)

inline bool operator==(Nullable<qint64> i1,int i2){return i1.operator==(i2);}
inline bool operator==(Nullable<quint32> i1,int i2){return i1.operator==(i2);}
inline bool operator==(Nullable<quint64> i1,int i2){return i1.operator==(i2);}
inline bool operator==(Nullable<quint64> i1,unsigned int i2){return i1.operator==(i2);}

#endif