typedefs.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/buffer/producer.hxx>
#include <StormByte/buffer/simple.hxx>
#include <StormByte/expected.hxx>
#include <StormByte/network/connection/protocol.hxx>
#include <StormByte/network/connection/rw.hxx>
#include <StormByte/network/connection/status.hxx>
#include <StormByte/network/exception.hxx>
 
#include <functional>
#include <future>
 
namespace StormByte::Network {
    namespace Connection {
        class Handler;                                                                                                                  
    }                                                                                                                                   
    class Packet;                                                                                                                       
    namespace Socket {  
        class Socket;                                                                                                                   
        class Client;                                                                                                                   
    }                                                                                                                                   
    namespace Socket {…}
    using FutureBuffer = std::future<Buffer::Simple>;                                                                                   
    using PromisedBuffer = std::promise<Buffer::Simple>;                                                                                
    using ExpectedBuffer = StormByte::Expected<Buffer::Simple, ConnectionError>;                                                        
    using ExpectedFutureBuffer = StormByte::Expected<FutureBuffer, ConnectionError>;                                                    
    using ExpectedVoid = StormByte::Expected<void, ConnectionError>;                                                                    
    using ExpectedClient = StormByte::Expected<Socket::Client, ConnectionError>;                                                        
    using ExpectedReadResult = StormByte::Expected<Connection::Read::Result, ConnectionClosed>;                                         
    using FutureBufferProcessor = std::function<StormByte::Expected<FutureBuffer, ConnectionError>(Socket::Client&, FutureBuffer&)>;    
    using SharedConsumerBuffer = std::shared_ptr<Buffer::Consumer>;                                                                 
    using SharedProducerBuffer = std::shared_ptr<Buffer::Producer>;                                                                 
    using ExpectedPacket = StormByte::Expected<std::shared_ptr<Packet>, PacketError>;                                                   
    using PacketInstanceFunction = std::function<std::shared_ptr<Packet>(const unsigned short&)>;                                       
    using PacketReaderFunction = std::function<ExpectedBuffer(const size_t&)>;                                                          
}