Optional.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Misc/Debug.h"

namespace honey
{

struct optnull_t {};
static optnull_t optnull;


template<class T>
class optional
{
    template<class T_> friend class optional;
public:
    optional()                                      : _val(nullptr) {}
    optional(optnull_t)                             : _val(nullptr) {}
    optional(const optional& rhs)                   : _val(nullptr) { if (rhs._val) construct(rhs.get()); }
    optional(optional& rhs)                         : _val(nullptr) { if (rhs._val) construct(rhs.get()); }
    optional(optional&& rhs)                        : _val(nullptr) { if (rhs._val) construct(move(rhs.get())); }
    template<class U> optional(const optional<U>& rhs)  : _val(nullptr) { if (rhs._val) construct(rhs.get()); }
    template<class U> optional(optional<U>& rhs)    : _val(nullptr) { if (rhs._val) construct(rhs.get()); }
    template<class U> optional(optional<U>&& rhs)   : _val(nullptr) { if (rhs._val) construct(move(rhs.get())); }
    template<class U> optional(U&& rhs)             : _val(nullptr) { construct(forward<U>(rhs)); }

    ~optional()                                     { uninit(); }

    optional& operator=(optnull_t)                  { uninit(); return *this; }

    optional& operator=(const optional& rhs)        { return operator=<T>(rhs); }
    optional& operator=(optional& rhs)              { return operator=<T>(rhs); }
    optional& operator=(optional&& rhs)             { return operator=<T>(move(rhs)); }
    template<class U> optional& operator=(const optional<U>& rhs)   { if (rhs._val) operator=(rhs.get()); else uninit(); return *this; }
    template<class U> optional& operator=(optional<U>& rhs)         { if (rhs._val) operator=(rhs.get()); else uninit(); return *this; }
    template<class U> optional& operator=(optional<U>&& rhs)        { if (rhs._val) operator=(move(rhs.get())); else uninit(); return *this; }
    

    template<class U> optional& operator=(U&& rhs)  { if (!_val) construct(forward<U>(rhs)); else get() = forward<U>(rhs); return *this; }

    bool operator==(optnull_t) const                { return !_val; }
    bool operator!=(optnull_t) const                { return !operator==(optnull); }

    const T& operator*() const                      { return get(); }
    T& operator*()                                  { return get(); }
    const T* operator->() const                     { return &get(); }
    T* operator->()                                 { return &get(); }
    operator const T&() const                       { return get(); }
    operator T&()                                   { return get(); }

    explicit operator bool() const                  { return _val; }
    explicit operator bool()                        { return _val; }

    const T& get() const                            { assert(_val, "Optional not initialized"); return *_val; }
    T& get()                                        { assert(_val, "Optional not initialized"); return *_val; }
    
    const T* ptr() const                            { return _val; }
    T* ptr()                                        { return _val; }

    friend ostream& operator<<(ostream& os, const optional& rhs)    { if (!rhs) return os << "optnull"; return os << *rhs; }

private:
    typedef typename std::aligned_storage<sizeof(T), alignof(T)>::type Storage;

    template<class U>
    void construct(U&& rhs)                         { _val = reinterpret_cast<T*>(&_storage); new (&_storage) T(forward<U>(rhs)); }
    void uninit()                                   { if (!_val) return; get().~T(); _val = nullptr; }

    T* _val;
    Storage _storage;
};


template<class T>
class optional<T&>
{
    template<class T_> friend class optional;
public:
    optional()                                      : _val(nullptr) {}
    optional(T* rhs)                                : _val(nullptr) { bind(rhs); }
    optional(optnull_t)                             : _val(nullptr) {}
    optional(const optional& rhs)                   : _val(nullptr) { bind(rhs._val); }
    optional(optional& rhs)                         : _val(nullptr) { bind(rhs._val); }
    optional(optional&& rhs)                        : _val(nullptr) { bind(rhs._val); }
    template<class U> optional(const optional<U>& rhs)  : _val(nullptr) { bind(rhs._val); }
    template<class U> optional(optional<U>& rhs)    : _val(nullptr) { bind(rhs._val); }
    template<class U> optional(optional<U>&& rhs)   : _val(nullptr) { bind(rhs._val); }
    template<class U> optional(U&& rhs)             : _val(nullptr) { bind(forward<U>(rhs)); }

    template<class U> void bind(U&& rhs)            { bind(&rhs); }
    template<class U> void bind(U* rhs)             { _val = rhs; }
    void bind(nullptr_t)                            { _val = nullptr; }
    
    optional& operator=(optnull_t)                  { bind(nullptr); return *this; }

    optional& operator=(const optional& rhs)        { return operator=<T&>(rhs); }
    optional& operator=(optional& rhs)              { return operator=<T&>(rhs); }
    optional& operator=(optional&& rhs)             { return operator=<T&>(move(rhs)); }
    template<class U> optional& operator=(const optional<U>& rhs)   { if (rhs._val) operator=(rhs.get()); return *this; }
    template<class U> optional& operator=(optional<U>& rhs)         { if (rhs._val) operator=(rhs.get()); return *this; }
    template<class U> optional& operator=(optional<U>&& rhs)        { if (rhs._val) operator=(move(rhs.get())); return *this; }
    
    template<class U> optional& operator=(U&& rhs)  { get() = forward<U>(rhs); return *this; }
    
    bool operator==(optnull_t) const                { return !_val; }
    bool operator!=(optnull_t) const                { return !operator==(optnull); }

    const T& operator*() const                      { return get(); }
    T& operator*()                                  { return get(); }
    const T* operator->() const                     { return &get(); }
    T* operator->()                                 { return &get(); }
    operator const T&() const                       { return get(); }
    operator T&()                                   { return get(); }

    explicit operator bool() const                  { return _val; }
    explicit operator bool()                        { return _val; }

    const T& get() const                            { assert(_val, "Optional not initialized"); return *_val; }
    T& get()                                        { assert(_val, "Optional not initialized"); return *_val; }

    const T* ptr() const                            { return _val; }
    T* ptr()                                        { return _val; }

    friend ostream& operator<<(ostream& os, const optional& rhs)    { if (!rhs) return os << "optnull"; return os << *rhs; }

private:
    T* _val;
};
    
}