Optional.h

Go to the documentation of this file.

#ifndef QEVERCLOUD_OPTIONAL_H
#define QEVERCLOUD_OPTIONAL_H

#include "EverCloudException.h"
#include <algorithm>

namespace qevercloud {

template<typename T>
class Optional
{
public:
    Optional() :
        m_isSet(false),
        m_value(T())
    {}

    Optional(const Optional & o) :
        m_isSet(o.m_isSet),
        m_value(o.m_value)
    {}

    template<typename X>
    Optional(const Optional<X> & o) :
        m_isSet(o.m_isSet),
        m_value(o.m_value)
    {}

    Optional(const T & value) :
        m_isSet(true),
        m_value(value)
    {}

    template<typename X>
    Optional(const X & value) :
        m_isSet(true),
        m_value(value)
    {}

    Optional & operator=(const Optional & o)
    {
        m_value = o.m_value;
        m_isSet = o.m_isSet;
        return *this;
    }

    template<typename X>
    Optional & operator=(const Optional<X> & o)
    {
        m_value = o.m_value;
        m_isSet = o.m_isSet;
        return *this;
    }

    Optional & operator=(const T & value)
    {
        m_value = value;
        m_isSet = true;
        return *this;
    }

    template<typename X>
    Optional & operator=(const X & value)
    {
        m_value = value;
        m_isSet = true;
        return *this;
    }

    operator const T&() const
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return m_value;
    }

    operator T&()
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return m_value;
    }

    const T & ref() const
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return m_value;
    }

    T & ref()
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return m_value;
    }

    bool isSet() const
    {
        return m_isSet;
    }

    void clear()
    {
        m_isSet = false;
        m_value = T();
    }

    Optional & init()
    {
        m_isSet = true;
        m_value = T();
        return *this;
    }

    T * operator->()
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return &m_value;
    }

    const T * operator->() const
    {
        if (!m_isSet) {
            throw EverCloudException("qevercloud::Optional: nonexistent value access");
        }

        return &m_value;
    }

    T value(T defaultValue = T()) const
    {
        return m_isSet ? m_value : defaultValue;
    }

    bool isEqual(const Optional<T> & other) const
    {
        if(m_isSet != other.m_isSet) return false;
        return !m_isSet || (m_value == other.m_value);
    }

    template<typename X> friend class Optional;

    friend void swap(Optional & first, Optional & second)
    {
        using std::swap;
        swap(first.m_isSet, second.m_isSet);
        swap(first.m_value, second.m_value);
    }

// Visual C++ does not to generate implicit move constructors so this stuff doesn't work with even recent MSVC compilers
#if defined(Q_COMPILER_RVALUE_REFS) && !defined(_MSC_VER)
    Optional(Optional && other)
    {
        swap(*this, other);
    }

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

    Optional(T && other)
    {
        using std::swap;
        m_isSet = true;
        swap(m_value, other);
    }

    Optional & operator=(T && other)
    {
        using std::swap;
        m_isSet = true;
        swap(m_value, other);
        return *this;
    }
#endif

private:
    bool m_isSet;
    T m_value;
};

} // namespace qevercloud

#endif // QEVERCLOUD_OPTIONAL_H