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

#ifndef WOLF_BASE_EXPORT
#define WOLF_BASE_EXPORT Q_DECL_IMPORT
#endif

#include <cstddef>

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

                template<typename T>bool operator==(const T*p)const{return p==nullptr;}
                template<typename T>bool operator!=(const T*p)const{return p!=nullptr;}
};

const NullValue nullval;

template<class T>class WOLF_BASE_EXPORT Nullable
{
        public:
                Nullable():isnull(true),elem(){}
                Nullable(const NullValue&):isnull(true),elem(){}
                //TODO: find an implementation that works without auto-casting 0 to nullptr while not using explicit
                explicit Nullable(const std::nullptr_t&):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;}
                T valueOrDefault()const{return value(T());}

                //convenience aliases, sometimes x.value().value().value() seems a bit weird!
                T& data(){return elem;}
                T data(const T&defaultval=T())const{if(isnull)return defaultval;else return elem;}
                T dataOrDefault()const{return value(T());}

                T* operator ->()const{if(isnull)return nullptr;else return const_cast<T*>(&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;}
                bool operator==(const std::nullptr_t&)const{return isnull;}
                bool operator!=(const std::nullptr_t&)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>)
Q_DECLARE_SMART_POINTER_METATYPE(Nullable)

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

#endif