optional.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef SERVLET_OPTIONAL_H
#define SERVLET_OPTIONAL_H

#include <utility>
#include <type_traits>

#include <servlet/lib/exception.h>

namespace servlet
{

template<typename T>
class optional_ptr
{
public:
    typedef T value_type;
    typedef T *pointer;
    typedef const T *const_pointer;

    constexpr optional_ptr() {}
    constexpr optional_ptr(T* ptr, bool owner = false) : _ptr{ptr}, _owner{owner} {}

    constexpr optional_ptr(const optional_ptr &other) = delete;
    constexpr optional_ptr(optional_ptr &&other) : _ptr{other._ptr}, _owner{other._owner}
    { other._ptr = nullptr; other._owner = false; }

    ~optional_ptr() noexcept { if (_owner) delete _ptr; }

    constexpr void clear()
    {
        if (_owner) delete _ptr;
        _ptr = nullptr; _owner = false;
    }

    constexpr optional_ptr& operator=(const optional_ptr &other) = delete;
    constexpr optional_ptr& operator=(optional_ptr &&other) noexcept
    {
        if (_owner) delete _ptr;
        _ptr = other._ptr; _owner = other._owner;
        other._ptr = nullptr; other._owner = false;
        return *this;
    }

    constexpr optional_ptr& assign(T* ptr, bool owner = false)
    {
        if (_owner) delete _ptr;
        _ptr = ptr; _owner = owner;
        return *this;
    }

    constexpr explicit operator bool() const noexcept { return _ptr != nullptr; }
    constexpr bool has_value() const noexcept { return _ptr != nullptr; }
    constexpr bool is_owner() const noexcept { return _owner; }

    constexpr T *operator->() { return _ptr ? _ptr : throw null_pointer_exception{"pointer is NULL"}; }
    constexpr const T *operator->() const
    { return _ptr ? _ptr : throw null_pointer_exception{"pointer is NULL"}; }

    constexpr T& operator*() & { if (!_ptr) throw null_pointer_exception{"pointer is NULL"}; return *_ptr; }
    constexpr const T& operator*() const& { if (!_ptr) throw null_pointer_exception{"pointer is NULL"}; return *_ptr; }

    constexpr void swap(optional_ptr &other) noexcept
    {
        T *tmp_ptr = _ptr;
        _ptr = other._ptr;
        other._ptr = tmp_ptr;
        bool tmp_owner = _owner;
        _owner = other._owner;
        other._owner = tmp_owner;
    }
    constexpr void reset() noexcept { clear(); }

private:
    bool _owner = false;
    T* _ptr = nullptr;
};

template<typename T>
class optional_ref
{
    T *_ptr = nullptr;
public:
    typedef T value_type;
    typedef T &reference;
    typedef const T &const_reference;

    constexpr optional_ref() noexcept {}
    constexpr optional_ref(T &obj) noexcept : _ptr{&obj} {}

    constexpr optional_ref(const optional_ref &other) noexcept : _ptr{other._ptr} {}
    constexpr optional_ref(optional_ref&& other) noexcept : _ptr{other._ptr} { other._ptr = nullptr; }

    ~optional_ref() noexcept {}

    constexpr optional_ref &operator=(const optional_ref &other) noexcept { _ptr = other._ptr; return *this; }
    constexpr optional_ref &operator=(optional_ref &&other) noexcept { _ptr = other._ptr; return *this; }
    constexpr optional_ref &operator=(T &obj) noexcept { _ptr = &obj; return *this; }

    constexpr T *operator->() { return _ptr ? _ptr : throw null_pointer_exception{"pointer is NULL"}; }
    constexpr const T *operator->() const { return _ptr ? _ptr : throw null_pointer_exception{"pointer is NULL"}; }

    constexpr T& operator*() { if (!_ptr) throw null_pointer_exception{"pointer is NULL"}; return *_ptr; }
    constexpr const T& operator*() const { if (!_ptr) throw null_pointer_exception{"pointer is NULL"}; return *_ptr; }

    constexpr explicit operator bool() const noexcept { return _ptr != nullptr; }
    constexpr bool has_value() const noexcept { return _ptr != nullptr; }

    constexpr T& value() & { return _ptr ? *_ptr : throw null_pointer_exception{"pointer is NULL"}; }
    constexpr const T& value() const& { return _ptr ? *_ptr : throw null_pointer_exception{"pointer is NULL"}; }

    template<typename OT>
    constexpr T value_or(OT&& dflt) const& noexcept
    {
        static_assert(std::is_copy_constructible<T>::value, "result is not copy constructable");
        static_assert(std::is_convertible<OT&&, T>::value, "default is not convertible to result");
        return _ptr == nullptr ? static_cast<T>(std::forward(dflt)) : *_ptr;
    }

    constexpr void swap(optional_ref &other) noexcept
    {
        T *tmp = _ptr;
        _ptr = other._ptr;
        other._ptr = tmp;
    }
    constexpr void reset() noexcept { _ptr = nullptr; }
};

template<typename CharT, typename Traits, typename T>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& out, const optional_ptr<T>& opt)
{
    if (opt) out << *opt;
    else out << "NULL";
    return out;
}
template<typename CharT, typename Traits, typename T>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& out, const optional_ref<T>& opt)
{
    if (opt) out << *opt;
    else out << "NULL";
    return out;
}

template<typename T>
constexpr bool operator==(const optional_ref<T> &l, const optional_ref<T> &r)
{
    return static_cast<bool>(l) == static_cast<bool>(r) && (!l || *l == *r);
}
template<typename T>
constexpr bool operator!=(const optional_ref<T> &l, const optional_ref<T> &r) { return !(l == r); }

template<typename T>
constexpr bool operator<(const optional_ref<T> &l, const optional_ref<T> &r)
{
    return static_cast<bool>(r) && (!l || *l < *r);
}

template<typename T>
constexpr bool operator>(const optional_ref<T> &l, const optional_ref<T> &r) { return r < l; }

template<typename T>
constexpr bool operator<=(const optional_ref<T> &l, const optional_ref<T> &r) { return !(r < l); }

template<typename T>
constexpr bool operator>=(const optional_ref<T> &l, const optional_ref<T> &r) { return !(l < r); }

template<typename T, typename U>
constexpr bool operator==(const optional_ref<T> &l, const U &r) { return l && *l == r; }

template<typename T, typename U>
constexpr bool operator==(const T &l, const optional_ref<T> &r) { return r && l == *r; }

template<typename T, typename U>
constexpr bool operator!=(const optional_ref<T> &l, U const &r) { return !l || !(*l == r); }

template<typename T, typename U>
constexpr bool operator!=(const U &l, const optional_ref<T> &r) { return !r || !(l == *r); }

template<typename T, typename U>
constexpr bool operator<(const optional_ref<T> &l, const U &r) { return !l || *l < r; }

template<typename T, typename U>
constexpr bool operator<(const U &l, const optional_ref<T> &r) { return r && l < *r; }

template<typename T, typename U>
constexpr bool operator>(const optional_ref<T> &l, const U &r) { return l && r < *l; }

template<typename T, typename U>
constexpr bool operator>(const U &l, const optional_ref<T> &r) { return !r || *r < l; }

template<typename T, typename U>
constexpr bool operator<=(const optional_ref<T> &l, const U &r) { return !l || !(r < *l); }

template<typename T, typename U>
constexpr bool operator<=(const U &l, const optional_ref<T> &r) { return r && !(*r < l); }

template<typename T, typename U>
constexpr bool operator>=(const optional_ref<T> &l, const U &r) { return l && !(*l < r); }

template<typename T, typename U>
constexpr bool operator>=(const U &l, const optional_ref<T> &r) { return !r || !(l < *r); }

template<typename T>
inline void swap(optional_ref<T> &l, optional_ref<T> &r) noexcept(noexcept(l.swap(r))) { l.swap(r); }

} // end of servlet namespace

#endif // SERVLET_OPTIONAL_H