typedefs.hxx

#pragma once
 
#include <StormByte/expected.hxx>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <span>
#include <type_traits>
#include <vector>
 
namespace StormByte::Buffer {
    namespace Read {
        enum class Position: unsigned short {
            Begin       = 0x01,     
            End         = 0x02,     
            Relative    = 0x04,     
            Absolute    = 0x08      
        };
 
        enum class Status: unsigned short {
            Success,                
            Error                   
        };
    }
 
    namespace Write {
        enum class Status: unsigned short {
            Success, 
            Error    
        };
    }
 
    enum class Status {
        Ready,                                                                          
        ReadOnly,                                                                       
        Error                                                                           
    };
    
    // Forward declarations
    class Simple;
 
    class Shared;
 
    class Producer;
 
    class Consumer;
 
    // Data types
    using Byte                          = std::byte;                                            
    using Data                          = std::vector<Byte>;                                    
    using ByteSpan                      = std::span<Byte>;                                      
    using ConstByteSpan                 = std::span<const Byte>;                                
    template<class T>
    using ExpectedByte                  = Expected<Byte, T>;                                    
    template<class T>
    using ExpectedByteRef               = Expected<Byte&, T>;                                   
    template<class T>
    using ExpectedByteSpan              = Expected<ByteSpan, T>;                                
    template<class T>
    using ExpectedConstByte             = Expected<const Byte, T>;                              
    template<class T>
    using ExpectedConstByteRef          = Expected<const Byte&, T>;                             
    template<class T>
    using ExpectedConstByteSpan         = Expected<std::span<const Byte>, T>;                   
    template<class T>
    using ExpectedData                  = Expected<Data, T>;                                    
    using PipeFunction                  = std::function<void(Consumer, Producer)>;              
    using Processor                     = std::function<std::shared_ptr<Simple>(const Simple&)>;
 
    template <typename PtrType, typename T,
        typename = std::enable_if_t<
            (std::is_same_v<PtrType, std::shared_ptr<typename PtrType::element_type>> ||
             std::is_same_v<PtrType, std::unique_ptr<typename PtrType::element_type>>)
        >
    >
    inline PtrType& operator<<(PtrType& ptr, const T& value) {
        static_assert(std::is_same_v<PtrType, std::shared_ptr<typename PtrType::element_type>> ||
                      std::is_same_v<PtrType, std::unique_ptr<typename PtrType::element_type>>,
                      "PtrType must be a std::shared_ptr or std::unique_ptr");
        if (ptr) {
            *ptr << value; // Forward the call to the existing operator<<
        }
        return ptr;
    }
 
    template <typename PtrType, typename T,
            typename = std::enable_if_t<
            (std::is_same_v<PtrType, std::shared_ptr<typename PtrType::element_type>> ||
             std::is_same_v<PtrType, std::unique_ptr<typename PtrType::element_type>>)
        >
    >
    inline PtrType& operator<<(PtrType& ptr, T&& value) {
        static_assert(std::is_same_v<PtrType, std::shared_ptr<typename PtrType::element_type>> ||
                      std::is_same_v<PtrType, std::unique_ptr<typename PtrType::element_type>>,
                      "PtrType must be a std::shared_ptr or std::unique_ptr");
        if (ptr) {
            *ptr << std::move(value); // Forward the call to the existing operator<<
        }
        return ptr;
    }
}