Any.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_ANY_HPP
#define AURORA_ANY_HPP

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

#include <typeindex>


namespace aurora
{


class Any
{
    // ---------------------------------------------------------------------------------------------------------------------------
    // Public member functions
    public:
        Any()
        : mPointer()
        , mType(typeid(void))
        {
        }

        template <typename T>
        Any(const T& value)
        : mPointer(makeCopied<T>(value))
        , mType(typeid(T))
        {
        }

        Any(const Any& origin)
        : mPointer(origin.mPointer)
        , mType(origin.mType)
        {
        }

        Any(Any&& source)
        : mPointer(std::move(source.mPointer))
        , mType(source.mType)
        {
        }

        template <typename T>
        Any& operator= (const T& value)
        {
            Any(value).swap(*this);
            return *this;
        }

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

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

        ~Any()
        {
        }

        void swap(Any& other)
        {
            adlSwap(mPointer, other.mPointer);
            adlSwap(mType, other.mType);
        }

        template <typename T>
        T& get()
        {
            assert(mType == typeid(T));
            return *static_cast<T*>(mPointer.get());
        }

        template <typename T>
        T* check()
        {
            if (mType == typeid(T))
                return static_cast<T*>(mPointer.get());
            else
                return nullptr;
        }

        operator SafeBool() const
        {
            return mPointer;
        }

    // ---------------------------------------------------------------------------------------------------------------------------
    // Private variables
    private:
        CopiedPtr<void>             mPointer;
        std::type_index             mType;
};

AURORA_GLOBAL_SWAP(Any)


} // namespace aurora

#endif // AURORA_ANY_HPP