maybe.h

Go to the documentation of this file.

#ifndef __SG_MAYBE_H__
#define __SG_MAYBE_H__

#include <shogun/lib/ShogunException.h>

namespace shogun
{

    namespace detail
    {
        static const char* NO_REASON_FOR_ABSENCE = "AVAILABLE";
    }

    class Nothing
    {
    public:
        Nothing(const char* reason = "no specific reason") :
            m_absence_reason(reason)
        {
        }
        Nothing(const Nothing& other) :
            m_absence_reason(other.m_absence_reason)
        {
        }
        const char* m_absence_reason;
    };

    template <typename T>
    class Maybe
    {
    public:
        Maybe(const Nothing& nothing) :
            m_value(),
            m_absence_reason(nothing.m_absence_reason)
        {
        }
        Maybe(const Maybe<T>& other) :
            m_value(other.m_value),
            m_absence_reason(other.m_absence_reason)
        {
        }

        inline operator bool() const
        {
            return is_present();
        }

        inline T& value()
        {
            return *get();
        }

        inline T& value_or(T& v)
        {
            if (is_present())
                return *get();
            else
                return v;
        }

        inline bool is_absent() const
        {
            return m_absence_reason != detail::NO_REASON_FOR_ABSENCE;
        }

        inline bool is_present() const
        {
            return m_absence_reason == detail::NO_REASON_FOR_ABSENCE;
        }

    private:
        inline T* get()
        {
            if (is_present())
                return &m_value;
            else
                throw ShogunException("Tried to access inexistent object");
        }
        Maybe();
        Maybe(const char* reason, bool) :
            m_value(),
            m_absence_reason(reason)
        {
        }
        Maybe(const T& someValue) :
            m_value(someValue),
            m_absence_reason(detail::NO_REASON_FOR_ABSENCE)
        {
        }

    public:
        template <typename Q>
        friend Maybe<Q> Just(const Q& value);

    private:
        T m_value;
        const char* m_absence_reason;
    };

    template <typename T>
    static Maybe<T> Just(const T& value)
    {
        return Maybe<T>(value);
    }

}
#endif