access_optional.h

Go to the documentation of this file.

 
#ifndef DD_DDL_ACCESS_OPTIONAL_H_INCLUDED
#define DD_DDL_ACCESS_OPTIONAL_H_INCLUDED
 
#include <stddef.h>
#include <utility>
 
namespace ddl {
namespace dd {
namespace utility {

template <typename T>
struct Optional {
    Optional() {};
    Optional(Optional&&) = default;
    Optional(const Optional&) = default;
    Optional& operator=(Optional&&) = default;
    Optional& operator=(const Optional&) = default;
    ~Optional() = default;

    typedef T value_type;

    Optional(const value_type& value) : _valid(true), _value(value)
    {
    }

    Optional& operator=(const value_type& value)
    {
        _valid = true;
        _value = value;
        return *this;
    }

    Optional(value_type&& value) : _valid(true), _value(value)
    {
    }

    Optional& operator=(value_type&& value)
    {
        _valid = true;
        _value = value;
        return *this;
    }

    operator bool() const
    {
        return _valid;
    }

    operator value_type() const
    {
        return _value;
    }

    value_type& operator*() &
    {
        return _value;
    }

    value_type&& operator*() &&
    {
        return std::move(_value);
    }

    const value_type& operator*() const&
    {
        return _value;
    }

    const value_type&& operator*() const&&
    {
        return std::move(_value);
    }

    void reset()
    {
        _valid = false;
    }

    value_type get() &
    {
        return _value;
    }

    value_type&& get() &&
    {
        return std::move(_value);
    }

    value_type get() const&
    {
        return _value;
    }

    value_type get() const&&
    {
        return std::move(_value);
    }

    bool operator==(const Optional& other) const
    {
        if (_valid) {
            return other._valid && (_value == other._value);
        }
        else {
            return !(other._valid);
        }
    }

    bool operator!=(const Optional& other) const
    {
        return !operator==(other);
    }

    bool _valid = false;
    value_type _value = {};
};
 
} // namespace utility
} // namespace dd
namespace utility {
using ::ddl::dd::utility::Optional;
using OptionalSize = Optional<size_t>;
} // namespace utility
} // namespace ddl
 
#endif // DD_DDL_ACCESS_OPTIONAL_H_INCLUDED