Optional.hpp

Go to the documentation of this file.

//
// Aurora C++ Library
// Copyright (c) 2012-2016 Jan Haller
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//


#ifndef AURORA_OPTIONAL_HPP
#define AURORA_OPTIONAL_HPP

#include <Aurora/Config.hpp>
#include <Aurora/Tools/SafeBool.hpp>
#include <Aurora/Tools/Swap.hpp>

#include <type_traits> // std::aligned_storage
#include <cassert>
#include <new> // placement new (g++ non-conformance, not required by C++ standard)


namespace aurora
{


const struct NulloptType {} nullopt;

const struct InplaceType {} inplace;

template <typename T>
class Optional
{
    // ---------------------------------------------------------------------------------------------------------------------------
    // Public member functions
    public:
        Optional()
        : mFilled(false)
        {
        }

        Optional(NulloptType)
        : mFilled(false)
        {
        }

#ifdef AURORA_HAS_VARIADIC_TEMPLATES

        template <typename... Args>
        explicit Optional(InplaceType, Args&&... args)
        : mFilled(false)
        {
            construct(std::forward<Args>(args)...);
        }

#endif // AURORA_HAS_VARIADIC_TEMPLATES

        Optional(T object)
        : mFilled(false)
        {
            construct(std::move(object));
        }

        Optional(const Optional& origin)
        : mFilled(false)
        {
            if (origin.mFilled)
                construct(origin.content());
        }

        Optional(Optional&& source)
        : mFilled(false)
        {
            if (source.mFilled)
            {
                construct(std::move(source.content()));
                source.destroy();
            }
        }

        Optional& operator= (T object)
        {
            Optional(std::move(object)).swap(*this);
            return *this;
        }

        Optional& operator= (const Optional& origin)
        {
            Optional(origin).swap(*this);
            return *this;
        }

        Optional& operator= (Optional&& source)
        {
            Optional(std::move(source)).swap(*this);
            return *this;
        }

        ~Optional()
        {
            if (mFilled)
                destroy();
        }

        void swap(Optional& other)
        {
            // TODO: Exception safety in 2nd and 3rd case

            if (mFilled && other.mFilled)
            {
                adlSwap(content(), other.content());
            }
            else if (mFilled)
            {
                other.construct(std::move(content()));
                this->destroy();
            }
            else if (other.mFilled)
            {
                this->construct(std::move(other.content()));
                other.destroy();
            }
        }

        T& operator* ()
        {
            return content();
        }

        const T& operator* () const
        {
            return content();
        }

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

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

        operator SafeBool() const
        {
            return toSafeBool(mFilled);
        }


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private member functions
    private:
        T& content()
        {
            assert(mFilled);
            return reinterpret_cast<T&>(mStorage);
        }

        const T& content() const
        {
            assert(mFilled);
            return reinterpret_cast<const T&>(mStorage);
        }

#ifdef AURORA_HAS_VARIADIC_TEMPLATES

        template <typename... Args>
        void construct(Args&&... args)
        {
            // Exception safety: set mFilled only to true after successful construction

            assert(!mFilled);
            new (&content()) T(std::forward<Args>(args)...);
            mFilled = true;
        }

#else

        void construct(T& source)
        {
            assert(!mFilled);
            new (&content()) T(std::move(source));
            mFilled = true;
        }

#endif // AURORA_HAS_VARIADIC_TEMPLATES

        void destroy()
        {
            assert(mFilled);
            content().~T();
            mFilled = false;
        }

    // ---------------------------------------------------------------------------------------------------------------------------
    // Private variables
    private:
        typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type mStorage;
        bool                                                                        mFilled;
};

template <typename T>
void swap(Optional<T>& lhs, Optional<T>& rhs)
{
    lhs.swap(rhs);
}

#ifdef AURORA_HAS_VARIADIC_TEMPLATES

template <typename T, typename... Args>
Optional<T> makeOptional(Args&&... args)
{
    return Optional<T>(inplace, std::forward<Args>(args)...);
}

#endif // AURORA_HAS_VARIADIC_TEMPLATES

template <typename T>
bool operator== (const Optional<T>& lhs, const Optional<T>& rhs)
{
    return !lhs && !rhs
        || lhs && rhs && *lhs == *rhs;
}

template <typename T>
bool operator!= (const Optional<T>& lhs, const Optional<T>& rhs)
{
    return !(lhs == rhs);
}


} // namespace aurora

#endif // AURORA_OPTIONAL_HPP