stack_ptr_decl.h

Go to the documentation of this file.

 
#ifndef A_UTIL_UTIL_MEMORY_DETAIL_STACK_PTR_DECL_HEADER_INCLUDED
#define A_UTIL_UTIL_MEMORY_DETAIL_STACK_PTR_DECL_HEADER_INCLUDED
 
#include <array>
 
namespace a_util {
namespace memory {
template <typename T,
          std::size_t StackSize = sizeof(T),
          std::size_t Alignment = alignof(std::size_t)>
class alignas(Alignment) StackPtr {
public:
    StackPtr();

    StackPtr(std::nullptr_t);

    StackPtr(const T& data);

    StackPtr(T&& data);

    ~StackPtr();

    StackPtr(const StackPtr& other);

    StackPtr& operator=(StackPtr other);

    StackPtr(StackPtr&& other);

    T* operator->();

    const T* operator->() const;

    T& operator*();

    const T& operator*() const;

    explicit operator bool() const noexcept;

    void reset();

    template <typename... Args>
    void reset(Args&&... args);

    void swap(StackPtr& other);
 
private: // types and constants
    enum StackPtrIntrospection {
        NumFlagBytes = 1,
        OverheadSize = (Alignment - (StackSize % Alignment)),
        StorageSize = StackSize + OverheadSize,
        FirstFlagPosition = StackSize
    };

    enum StackPtrFlagPositions {
        InitializeStatus = FirstFlagPosition 
    };

    enum class StackPtrFlags : char {
        IsDestroyed = 0x00,  
        IsConstructed = 0x01 
    };
 
private:
    void* address();

    const void* address() const;

    void setFlag(StackPtrFlagPositions position, StackPtrFlags flag);

    bool isConstructed() const noexcept;

    template <typename U, std::size_t SSize, std::size_t A>
    friend bool operator==(const StackPtr<U, SSize, A>& lhs, const StackPtr<U, SSize, A>& rhs);
 
private:
    std::array<char, StorageSize> _storage;
};

template <typename T, std::size_t StackSize, std::size_t Alignment>
void swap(StackPtr<T, StackSize, Alignment>& lhs, StackPtr<T, StackSize, Alignment>& rhs);

template <typename T, std::size_t StackSize, std::size_t Alignment>
bool operator!=(const StackPtr<T, StackSize, Alignment>& lhs,
                const StackPtr<T, StackSize, Alignment>& rhs);

template <typename T,
          std::size_t StackSize = sizeof(T),
          std::size_t Alignment = alignof(std::size_t),
          typename... Args>
constexpr auto makeStackPtr(Args&&... args) -> StackPtr<T, StackSize, Alignment>;
 
} // namespace memory
} // namespace a_util
 
#endif // A_UTIL_UTIL_MEMORY_DETAIL_STACK_PTR_DECL_HEADER_INCLUDED