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>
 
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;
    }
 
    const value_type operator*() const
    {
        return _value;
    }
 
    void reset()
    {
        _valid = false;
    }
    value_type get() const
    {
        return _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