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