Memory.h

 
#ifndef ACTIVE_UTILITY_MEMORY
#define ACTIVE_UTILITY_MEMORY
 
#include "Active/Utility/Cloner.h"
 
#include <bit>
#include <memory>
#include <optional>
 
namespace active::utility {
    
    class Memory: public utility::Cloner {
    public:
 
        inline static constexpr bool defaultEndian{std::endian::native == std::endian::big};
        
        // MARK: - Types
        
        using size_type = std::size_t;
        using sizeOption = std::optional<size_type>;
        using Option = std::optional<Memory>;
        using Unique = std::unique_ptr<Memory>;
        using Shared = std::shared_ptr<Memory>;
        
        // MARK: - Static functions
        
        static void fill(void* start, size_type size, char fillChar = 0);
        template<typename T>
        static void erase(T& target) { fill(&target, sizeof(target)); }
        static size_type copy(char* dest, char* source, size_type destSize, size_type sourceSize);
        template<typename T> requires (std::is_integral_v<T>)
        static T toBigEndian(T val) {
                //Return the given value unchanged if the processor is big-endian
            if (defaultEndian)
                return val;
            byteSwap(val);
            return val;
        }
        template<typename T> requires (std::is_integral_v<T>)
        static T fromBigEndian(T val) {
                //Return the given value unchanged if the processor is big-endian
            if (defaultEndian)
                return val;
            byteSwap(val);
            return val;
        }
        template<typename T> requires (std::is_integral_v<T>)
        static void byteSwap(T& val) {
            auto* data = reinterpret_cast<unsigned char*>(&val);
            auto bytes = sizeof(T);
            for (auto i = bytes-- / 2; i--; )
                std::swap(data[i], data[bytes - i]);
        }
        template<typename T> requires (std::is_integral_v<T>)
        static void byteSwap(T* val, size_type howMany, bool toBigEndian) {
            if ((howMany < 1) || (toBigEndian == defaultEndian))
                return;
            for (; howMany--; ++val) {
                auto data = reinterpret_cast<unsigned char*>(val);
                auto bytes = sizeof(T);
                for (auto i = bytes-- / 2; i--; )
                    std::swap(data[i], data[bytes - i]);
            }
        }
 
        // MARK: - Constructors
        
        Memory() {}
        template<typename T> requires (sizeof(T) > 1) && (!std::is_pointer<T>())
        Memory(T& buffer, bool makeCopy = false, bool takeOwnership = false) : Memory{&buffer, sizeof(buffer), makeCopy, takeOwnership} {}
        Memory(void* location, size_type size, bool makeCopy = false, bool takeOwnership = false);
        Memory(const Memory& source);
        Memory(Memory&& source) noexcept;
        
        Memory* clonePtr() const override { return new Memory{*this}; }
        
        // MARK: - Operators
        
        Memory& operator= (const Memory& source);
        Memory& operator= (Memory&& source) noexcept;
        operator bool() const { return !empty(); }
        char operator[] (size_type index) const;
        char& operator[] (size_type index);
        
        // MARK: - Functions (const)
        
        char* data() const { return m_location; }
        size_type size() const { return (m_location == nullptr) ? 0 : m_size.value_or(m_allocSize); }
        bool empty() const { return (size() == 0); }
        bool owned() const { return m_store.operator bool() || (m_location == nullptr); }
        
        // MARK: - Functions (mutating)
        
        char* data() { return m_location; }
 
        Memory& resize(size_type newSize, std::optional<char> fillChar = std::nullopt);
        Memory& append(const Memory& source, size_type startPos = 0, std::optional<size_type> howMany = std::nullopt);
        void fill(char fillChar = 0);
        void clear(bool isReleased = true);
        char* release();
 
    private:
        Memory& reallocate(size_type size, std::optional<char> fillChar = std::nullopt, bool retainExisting = true);
            
        char* m_location = nullptr;
        sizeOption m_size;
        size_type m_allocSize = 0;
        std::unique_ptr<char[]> m_store;
    };
    
}
 
#endif  //ACTIVE_UTILITY_MEMORY