Nullable.h

Go to the documentation of this file.

#pragma once

template <typename T>
class Nullable
{
private:
        T m_value;
        bool m_isSet;

        void set(T value)
        {
                m_value = value;
                m_isSet = true;
        }

public:
        Nullable() : m_value(), m_isSet(false)
        {
        }

        Nullable(T value) : m_value(value), m_isSet(true)
        {
        }

        Nullable(const Nullable& other) : m_value(other.m_value), m_isSet(other.m_isSet)
        {
        }

        /*friend void swap(Nullable& a, Nullable& b)
        {
                std::swap(a.m_isSet, b.m_isSet);
                std::swap(a.m_value, b.m_value);
        }

        Nullable& operator=(Nullable other)
        {
                swap(*this, other);
                return *this;
        }*/

        T operator=(T value)
        {
                set(value);
                return m_value;
        }

        bool operator==(const T value)
        {
                return m_isSet && value == m_value;
        }

        bool operator==(const Nullable& other)
        {
                if (other.is_set() != m_isSet ||
                        (other.is_set() && m_isSet && other.get() != m_value))
                        return false;
                
                return true;
        }

        bool operator!=(const Nullable& other)
        {
                if (other.is_set() != m_isSet ||
                        (other.is_set() && m_isSet && other.get() != m_value))
                        return true;
                
                return false;
        }

        operator T() const
        {
                return get();
        }

        T get() const
        {
                if (m_isSet) return m_value;
                
                throw std::logic_error("Value of Nullable is not set.");
        }

        bool is_set() const
        {
                return m_isSet;
        }

        void reset()
        {
                m_isSet = false;
        }
};