FastEngine 0.9.3
A multiplayer oriented 2D engine made with Vulkan.
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Attributes | Protected Attributes | List of all members
fge::net::ProtocolPacket Class Reference
Network

A special inheritance of Packet with a predefined communication protocol. More...

#include <C_protocol.hpp>

Inheritance diagram for fge::net::ProtocolPacket:
fge::net::Packet fge::net::FluxPacket

Public Types

using Header = uint16_t
 
using Realm = uint8_t
 
using CountId = uint16_t
 

Public Member Functions

 ProtocolPacket (Header header, Realm realmId, CountId countId)
 
 ProtocolPacket (ProtocolPacket const &r)=default
 
 ProtocolPacket (Packet const &r)
 
 ProtocolPacket (ProtocolPacket &&r) noexcept=default
 
 ProtocolPacket (Packet &&r) noexcept
 
Packet & packet () noexcept
 
Packet const & packet () const noexcept
 
bool haveCorrectHeaderSize () const
 
std::optional< Header > retrieveHeader () const
 
std::optional< Header > retrieveHeaderId () const
 
std::optional< Realm > retrieveRealm () const
 
std::optional< CountId > retrieveCountId () const
 
void setHeader (Header header)
 
void setHeaderId (Header headerId)
 
void setHeaderFlags (Header headerFlags)
 
void addHeaderFlags (Header headerFlags)
 
void removeHeaderFlags (Header headerFlags)
 
void setRealm (Realm realmId)
 
void setCountId (CountId countId)
 
void clear ()
 
void flush ()
 
void reserve (std::size_t reserveSize)
 
fge::net::Packet & append (std::size_t size)
 
fge::net::Packet & append (void const *data, std::size_t size)
 
fge::net::Packet & pack (void const *data, std::size_t size)
 
bool pack (std::size_t pos, void const *data, std::size_t size)
 
bool write (std::size_t pos, void const *data, std::size_t size)
 
fge::net::Packet const & read (void *buff, std::size_t size) const
 
bool read (std::size_t pos, void *buff, std::size_t size) const
 
fge::net::Packet const & unpack (void *buff, std::size_t size) const
 
bool unpack (std::size_t pos, void *buff, std::size_t size) const
 
fge::net::Packet & shrink (std::size_t size)
 
bool erase (std::size_t pos, std::size_t size)
 
fge::net::Packet const & skip (std::size_t size) const
 
void setReadPos (std::size_t pos) const
 
std::size_t getReadPos () const
 
bool isExtractable (std::size_t size) const
 
uint8_t const * getData (std::size_t pos) const
 
uint8_t * getData (std::size_t pos)
 
uint8_t const * getData () const
 
uint8_t * getData ()
 
std::size_t getDataSize () const
 
uint32_t getLength () const
 
void invalidate () const
 
void setValidity (bool validity) const
 
bool isValid () const
 
 operator bool () const
 
bool endReached () const
 
fge::net::Packet & operator<< (bool data)
 
fge::net::Packet & operator<< (int8_t data)
 
fge::net::Packet & operator<< (int16_t data)
 
fge::net::Packet & operator<< (int32_t data)
 
fge::net::Packet & operator<< (int64_t data)
 
fge::net::Packet & operator<< (uint8_t data)
 
fge::net::Packet & operator<< (uint16_t data)
 
fge::net::Packet & operator<< (uint32_t data)
 
fge::net::Packet & operator<< (uint64_t data)
 
fge::net::Packet & operator<< (float data)
 
fge::net::Packet & operator<< (double data)
 
fge::net::Packet & operator<< (long double data)
 
fge::net::Packet & operator<< (std::string_view const &data)
 
fge::net::Packet & operator<< (char const *data)
 
fge::net::Packet & operator<< (std::string const &data)
 
fge::net::Packet & operator<< (tiny_utf8::string const &data)
 
fge::net::Packet & operator<< (wchar_t const *data)
 
fge::net::Packet & operator<< (std::wstring const &data)
 
template<typename T >
fge::net::Packet & operator<< (std::forward_list< T > const &data)
 
template<typename T >
fge::net::Packet & operator<< (std::list< T > const &data)
 
template<typename T >
fge::net::Packet & operator<< (std::vector< T > const &data)
 
template<typename T >
fge::net::Packet & operator<< (fge::Vector2< T > const &data)
 
template<typename T >
fge::net::Packet & operator<< (fge::Vector3< T > const &data)
 
template<typename T >
fge::net::Packet & operator<< (fge::Matrix< T > const &data)
 
fge::net::Packet & operator<< (fge::Color const &data)
 
template<class TEnum , typename = std::enable_if_t<std::is_enum_v<TEnum>>>
fge::net::Packet & operator<< (TEnum const &data)
 
template<class TData >
fge::net::Packet & operator<< (std::unique_ptr< TData > const &data)
 
fge::net::Packet const & operator>> (bool &data) const
 
fge::net::Packet const & operator>> (int8_t &data) const
 
fge::net::Packet const & operator>> (int16_t &data) const
 
fge::net::Packet const & operator>> (int32_t &data) const
 
fge::net::Packet const & operator>> (int64_t &data) const
 
fge::net::Packet const & operator>> (uint8_t &data) const
 
fge::net::Packet const & operator>> (uint16_t &data) const
 
fge::net::Packet const & operator>> (uint32_t &data) const
 
fge::net::Packet const & operator>> (uint64_t &data) const
 
fge::net::Packet const & operator>> (float &data) const
 
fge::net::Packet const & operator>> (double &data) const
 
fge::net::Packet const & operator>> (long double &data) const
 
fge::net::Packet const & operator>> (char *data) const
 
fge::net::Packet const & operator>> (std::string &data) const
 
fge::net::Packet const & operator>> (tiny_utf8::string &data) const
 
fge::net::Packet const & operator>> (wchar_t *data) const
 
fge::net::Packet const & operator>> (std::wstring &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::forward_list< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::list< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::vector< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Vector2< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Vector3< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Matrix< T > &data) const
 
fge::net::Packet const & operator>> (fge::Color &data) const
 
template<class TEnum , typename = std::enable_if_t<std::is_enum_v<TEnum>>>
fge::net::Packet const & operator>> (TEnum &data) const
 
template<class TData >
fge::net::Packet const & operator>> (std::unique_ptr< TData > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::forward_list< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::list< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (std::vector< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Vector2< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Vector3< T > &data) const
 
template<typename T >
fge::net::Packet const & operator>> (fge::Matrix< T > &data) const
 
template<class TEnum , typename >
fge::net::Packet const & operator>> (TEnum &data) const
 
template<class TData >
fge::net::Packet const & operator>> (std::unique_ptr< TData > &data) const
 
bool operator== (Packet const &right) const =delete
 
bool operator!= (Packet const &right) const =delete
 
virtual void onSend (std::vector< uint8_t > &buffer, std::size_t offset)
 
virtual void onReceive (void *data, std::size_t size)
 

Static Public Attributes

static constexpr std::size_t HeaderSize = sizeof(Header) + sizeof(Realm) + sizeof(CountId)
 
static constexpr std::size_t HeaderIdPosition = 0
 
static constexpr std::size_t RealmPosition = sizeof(Header)
 
static constexpr std::size_t CountIdPosition = sizeof(Header) + sizeof(Realm)
 
static std::size_t _defaultReserveSize
 

Protected Attributes

std::size_t _g_sendPos
 
std::vector< uint8_t > _g_lastData
 
bool _g_lastDataValidity
 
std::vector< uint8_t > _g_data
 
std::size_t _g_readPos
 
bool _g_valid
 

Detailed Description

A special inheritance of Packet with a predefined communication protocol.

This class is used to handle the communication between the server and the client.

The documentation for this class was generated from the following files:
Generated by doxygen 1.12.0