PImpl.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_PIMPL_HPP
#define AURORA_PIMPL_HPP

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

#include <type_traits> // std::aligned_storage


namespace aurora
{


template <typename T, std::size_t Size, std::size_t Align>
class PImpl
{
    // ---------------------------------------------------------------------------------------------------------------------------
    // Public member functions
    public:
        template <typename... Args>
        explicit PImpl(Args&&... args)
        {
            check();
            new (storage()) T(std::forward<Args>(args)...);
        }

        PImpl(const PImpl& origin)
        {
            check();
            new (storage()) T(*origin.storage());
        }

        PImpl(PImpl&& source)
        {
            check();
            new (storage()) T(std::move(*source.storage()));
        }

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

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

        ~PImpl()
        {
            storage()->~T();
        }

        void swap(PImpl& other)
        {
            adlSwap(*storage(), *other.storage());
        }

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

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

        T* operator-> ()
        {
            return storage();
        }

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


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private member functions
    private:
        T* storage()
        {
            return reinterpret_cast<T*>(&mStorage);
        }

        const T* storage() const
        {
            return reinterpret_cast<const T*>(&mStorage);
        }

        void check()
        {
            correctSizeAndAlignWouldBe<sizeof(T), std::alignment_of<T>::value>();
        }

        template <std::size_t ActualSize, std::size_t ActualAlign>
        void correctSizeAndAlignWouldBe()
        {
            static_assert(ActualSize <= Size, "PImpl: Size too small to hold type T");
            static_assert(ActualAlign == Align, "PImpl: Alignment mismatch for type T");
        }


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private variables
    private:
        typename std::aligned_storage<Size, Align>::type mStorage;
};

template <typename T, std::size_t Size, std::size_t Align>
void swap(PImpl<T, Size, Align>& lhs, PImpl<T, Size, Align>& rhs)
{
    lhs.swap(rhs);
}


} // namespace aurora

#endif // AURORA_PIMPL_HPP