RawStorage.h

Go to the documentation of this file.

#pragma once
#include <scl/macros.h>
#include <scl/exceptions/UninitializedMemoryAccess.h>
#include <scl/tools/meta/type_query.h>

namespace scl{
    namespace utils{
        template <class T>
        class RawStorage{
            protected:
                 using storage_type = META::aligned_storage_t<sizeof(T), alignof(T)>;

                bool init;

                storage_type storage;

                storage_type* rawPtr(){
                    return &storage;
                }

                T* ptr(){
                    return reinterpret_cast<T*>(this->rawPtr());
                }

            public:
                RawStorage() : init{false}, storage{} {
                }

                ~RawStorage(){
                    this->destructor();
                }

                RawStorage(RawStorage&& other){
                    *this = std::move(other);
                }

                RawStorage& operator=(RawStorage&& other){
                    this->init = other.init;
                    this->constructor(std::move(other.get()));
                    other.init = false; //set the correct move semantics
                    return *this;
                }

                template <class... Args>
                T& constructor(Args&&... args){
                    this->destructor();
                    new( rawPtr() )T{std::forward<Args>(args)...};
                    this->init = true;
                    return this->get();
                }

                void destructor(){
                    if(this->init) {
                        this->ptr()->~T();
                        this->init = false;
                    }
                }

                template <class... Args>
                T& construct(Args&&... args){
                    return this->constructor(std::forward<Args&&>(args)...);
                }

                void destroy(){
                    this->destructor();
                }

                RawStorage& reset(){
                    this->destroy();
                    return *this;
                }

                T& get(){
                    if(!this->init)
                        throw scl::exceptions::UninitializedMemoryAccess{};

                    return *ptr();
                }

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

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

                const T& get() const{
                    if(!this->init)
                        throw scl::exceptions::UninitializedMemoryAccess{};

                    return *reinterpret_cast<const T*>(&this->storage);
                }

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

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

                bool hasValue() const{
                    return this->init;
                }

                operator bool() const{
                    return this->hasValue();
                }
        };
    }
}