StormByte-Network 4.0.0
C++26 networking module of the StormByte suite
Loading...
Searching...
No Matches
typedefs.hxx
Go to the documentation of this file.
1/*
2 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
3 *
4 * This file is part of StormByte-Network.
5 *
6 * StormByte-Network original source is dual-licensed:
7 *
8 * 1. GNU Lesser General Public License v3.0 (or later)
9 * You may redistribute and/or modify this file under the terms of the
10 * GNU Lesser General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option)
12 * any later version.
13 *
14 * 2. Commercial license
15 * Alternatively, this file may be used under the terms of a commercial
16 * license agreement with the copyright holder
17 * (David C. Manuelda <StormByte@gmail.com>).
18 *
19 * Both licenses apply only to original StormByte-Network source in this
20 * repository. They do not cover other StormByte modules or any third-party
21 * material shipped with this repository (including everything under
22 * thirdparty/, and in particular the bundled StormByte Buffer tree), which
23 * remains under its own license.
24 *
25 * Neither license grants any patent rights. Any patent licenses required
26 * to use this software or third-party components must be obtained separately
27 * from the patent holders.
28 *
29 * StormByte-Network is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 * GNU Lesser General Public License for more details.
33 *
34 * You should have received a copy of the GNU Lesser General Public License
35 * version 3 along with StormByte-Network. If not, see
36 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
37 *
38 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
39 */
40
41#pragma once
42
43#include <StormByte/buffer/consumer.hxx>
44#include <StormByte/buffer/fifo.hxx>
45#include <StormByte/expected.hxx>
46#include <StormByte/logger/log.hxx>
52#include <StormByte/safe/pointers.hxx>
53#include <StormByte/type_traits.hxx>
54
55#ifdef WINDOWS
56#include <winsock2.h>
57#endif
58
59#include <utility>
60
65namespace StormByte {
70 namespace Network {
75 namespace Socket {
80 class Socket;
81
86 class Client;
87 }
88
93 namespace Connection {
94 #ifdef UNIX
98 using HandlerType = int;
99 #else
103 using HandlerType = SOCKET;
104 #endif
105 }
106
111
116
121
126
133
144 public:
149
155
160 using CloneFunction = void* (*)(const void*);
161
165 using DestroyFunction = void (*)(void*) noexcept;
166
170 DeserializePacketFunction() noexcept = default;
171
177 template<typename Callable>
178 requires (!StormByte::Type::SameAs<std::decay_t<Callable>, DeserializePacketFunction>
179 && StormByte::Type::CopyConstructible<std::decay_t<Callable>>)
181 m_context(new std::decay_t<Callable>(std::forward<Callable>(callable))),
182 m_invoke(&Invoke<std::decay_t<Callable>>),
183 m_clone(&Clone<std::decay_t<Callable>>),
184 m_destroy(&Destroy<std::decay_t<Callable>>) {}
185
191
197
202
209
216
224 STORMBYTE_NETWORK_PUBLIC PacketPointer operator()(OpcodeType opcode, Buffer::Consumer payload,
225 StormByte::Safe::Shared<Logger::Log> logger) const;
226
231 explicit operator bool() const noexcept {
232 return m_context != nullptr;
233 }
234
235 private:
245 template<typename Callable>
246 static PacketPointer Invoke(void* context, OpcodeType opcode, Buffer::Consumer payload,
248 return (*static_cast<Callable*>(context))(opcode, std::move(payload), std::move(logger));
249 }
250
257 template<typename Callable>
258 static void* Clone(const void* context) {
259 return new Callable(*static_cast<const Callable*>(context));
260 }
261
267 template<typename Callable>
268 static void Destroy(void* context) noexcept {
269 delete static_cast<Callable*>(context);
270 }
271
272 void* m_context = nullptr;
273 InvokeFunction m_invoke = nullptr;
274 CloneFunction m_clone = nullptr;
275 DestroyFunction m_destroy = nullptr;
276 };
277 }
278}
279
STORMBYTE_DECLARE_MAYBE_SAFE(StormByte::Buffer::Bridge)
Forward declaration of the connected client implementation.
Forward declaration of the socket abstraction.
Connection or socket operation failed.
Definition exception.hxx:163
Caller-owned callback that builds a packet from opcode and payload.
Definition typedefs.hxx:143
~DeserializePacketFunction() noexcept
Destroy through the caller's destruction trampoline.
Transport::Packet::OpcodeType OpcodeType
Wire opcode type.
Definition typedefs.hxx:148
DeserializePacketFunction(DeserializePacketFunction &&other) noexcept
Transfer callback ownership without touching its target.
void(*)(void *) noexcept DestroyFunction
Caller-allocator destroy trampoline taking context storage.
Definition typedefs.hxx:165
void *(*)(const void *) CloneFunction
Caller-allocator clone trampoline taking source context storage.
Definition typedefs.hxx:160
PacketPointer(*)(void *, OpcodeType, Buffer::Consumer, StormByte::Safe::Shared< Logger::Log >) InvokeFunction
Invocation trampoline taking context, opcode, payload, and logger.
Definition typedefs.hxx:154
DeserializePacketFunction() noexcept=default
Construct an empty callback.
DeserializePacketFunction(const DeserializePacketFunction &other)
Clone using the caller's target allocator trampoline.
unsigned short OpcodeType
Opcode storage type.
Definition packet.hxx:78
int HandlerType
Native POSIX socket handle.
Definition typedefs.hxx:98
Private native transport implementation.
Network module of the StormByte suite.
StormByte::Expected< Buffer::FIFO, ConnectionError > ExpectedBuffer
Receive buffer or connection error result.
Definition typedefs.hxx:110
StormByte::Expected< void, ConnectionError > ExpectedVoid
Void operation or connection error result.
Definition typedefs.hxx:115
StormByte::Expected< Connection::Read::Result, ConnectionClosed > ExpectedReadResult
Wait-for-data result or closed connection error.
Definition typedefs.hxx:125
StormByte::Safe::Shared< Transport::Packet > PacketPointer
Base-heap shared packet pointer.
Definition typedefs.hxx:132
StormByte::Expected< StormByte::Safe::Shared< Socket::Client >, ConnectionError > ExpectedClient
Accepted client or connection error result.
Definition typedefs.hxx:120
Root namespace of the StormByte suite.
std::conditional_t< Type::Reference< T >, std::expected< std::reference_wrapper< std::remove_reference_t< T > >, Safe::Shared< E > >, std::expected< T, Safe::Shared< E > > > Expected
STL namespace.
#define STORMBYTE_FORCE_INLINE
#define STORMBYTE_NETWORK_PUBLIC
Definition visibility.h:51