EntropyEngine::Networking::SessionManager

EntropyEngine::Networking::SessionManager

Slot-based session manager for protocol-level operations. More…

#include <SessionManager.h>

Inherits from EntropyEngine::Core::EntropyObject

Public Types

	Name
using NetworkSession::UpdateMaterialPropertyResponseCallback	UpdateMaterialPropertyResponseCallback
using NetworkSession::UpdateMaterialPropertyCallback	UpdateMaterialPropertyCallback
using NetworkSession::UpdateMaterialPropertiesBatchResponseCallback	UpdateMaterialPropertiesBatchResponseCallback
using NetworkSession::UpdateMaterialPropertiesBatchCallback	UpdateMaterialPropertiesBatchCallback
using std::function< void(bool success, const std::string &errorMessage)>	SetSceneEnabledResponseCallback
using std::function< void(uint64_t sceneId, bool enabled)>	SetSceneEnabledCallback
using std::function< void(const std::vector< uint8_t > &data)>	SceneSnapshotCallback
using std::function< void(const std::vector< uint8_t > &data)>	PropertyUpdateCallback
using NetworkSession::PropertyRegistrationInfo	PropertyRegistrationInfo
using NetworkSession::MaterialUnsubscribeResponseCallback	MaterialUnsubscribeResponseCallback
using NetworkSession::MaterialUnsubscribeCallback	MaterialUnsubscribeCallback
using NetworkSession::MaterialSubscribeResponseCallback	MaterialSubscribeResponseCallback
using NetworkSession::MaterialSubscribeCallback	MaterialSubscribeCallback
using NetworkSession::MaterialResolvedCallback	MaterialResolvedCallback
using NetworkSession::MaterialPropertyUpdateCallback	MaterialPropertyUpdateCallback
using NetworkSession::MaterialPropertyData	MaterialPropertyData
using NetworkSession::MaterialAssetData	MaterialAssetData
using std::function< void(uint64_t timestamp)>	HeartbeatCallback
using std::function< void(const std::string &clientType, const std::string &clientId)>	HandshakeCallback
using NetworkSession::GetMaterialResponseCallback	GetMaterialResponseCallback
using NetworkSession::GetMaterialCallback	GetMaterialCallback
using std::function< void(NetworkError error, const std::string &message)>	ErrorCallback
using std::function< void(uint64_t entityId)>	EntityDestroyedCallback
using NetworkSession::EntityCreatedCallback	EntityCreatedCallback
using std::function< void(bool success, const std::string &errorMessage)>	DestroySceneResponseCallback
using std::function< void(uint64_t sceneId)>	DestroySceneCallback
using std::function< void(bool success, uint64_t sceneId, const std::string &errorMessage)>	CreateSceneResponseCallback
using std::function< void(const std::string &sceneName, bool transient)>	CreateSceneCallback
using NetworkSession::CreateMaterialResponseCallback	CreateMaterialResponseCallback
using NetworkSession::CreateMaterialCallback	CreateMaterialCallback
using NetworkSession::ComponentGroupData	ComponentGroupData
using std::function< void(uint64_t requestId, bool success, uint32_t removedCount, const std::string &errorMessage)>	AssetWithdrawResponseCallback
using std::function< void(const std::vector< std::array< uint8_t, 32 > > &assetIds, uint64_t requestId)>	AssetWithdrawCallback
using std::function< void(uint64_t requestId, bool success, uint32_t removedCount, const std::string &errorMessage)>	AssetWithdrawAllResponseCallback
using std::function< void(const std::string &appId, uint64_t requestId)>	AssetWithdrawAllCallback
using std::function< void(uint64_t requestId, bool success, const std::array< uint8_t, 32 > &assetId, const std::string &uri, const std::string &errorMessage)>	AssetUploadResponseCallback
using std::function< void(const NetworkSession::AssetUploadCompleteResponseData &data)>	AssetUploadCompleteResponseCallback
using std::function< void(const NetworkSession::AssetUploadChunkResponseData &data)>	AssetUploadChunkResponseCallback
using std::function< void(bool success, const std::string &errorMessage)>	AssetUploadCancelResponseCallback
using std::function< void(const std::string &appId, const std::vector< uint8_t > &data, uint8_t contentType, bool persistent, uint64_t requestId, const NetworkSession::AssetMetadataData &metadata)>	AssetUploadCallback
using std::function< void(const NetworkSession::AssetUploadBeginResponseData &data)>	AssetUploadBeginResponseCallback
using NetworkSession::AssetResolveResponseData	AssetResolveResponseData
using std::function< void(uint64_t requestId, const AssetResolveResponseData &response)>	AssetResolveResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, uint64_t requestId)>	AssetResolveCallback
using std::function< void(uint64_t requestId, const std::vector< AssetResolveResponseData > &responses)>	AssetResolveBatchResponseCallback
using std::function< void(const std::vector< std::array< uint8_t, 32 > > &assetIds, uint64_t requestId)>	AssetResolveBatchCallback
using std::function< void(uint64_t requestId, bool success, const std::string &errorMessage)>	AssetProvideKeyResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, const std::array< uint8_t, 32 > &key, uint64_t requestId)>	AssetProvideKeyCallback
using std::function< void( uint64_t requestId, bool found, const std::vector< uint8_t > &data, const std::string &errorMessage)>	AssetFetchResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, uint64_t requestId)>	AssetFetchCallback
using NetworkSession::AssetEntryData	AssetEntryData
using std::function< void(uint64_t requestId, bool success, const std::string &errorMessage)>	AssetAdvertiseResponseCallback
using std::function< void(const std::string &appId, const std::vector< AssetEntryData > &entries, uint64_t requestId)>	AssetAdvertiseCallback
using std::function< void(bool success, const std::string &errorMessage)>	AddEntityToSceneResponseCallback
using std::function< void(uint64_t entityId, uint64_t sceneId)>	AddEntityToSceneCallback

Public Functions

	Name
	~SessionManager()
virtual std::string	toString() const override Human-readable short string (class@ptr by default).
bool	supportsMultipleChannels(const SessionHandle & handle) Check if session’s connection supports multiple data channels.
Result< void >	setUpdateMaterialPropertyResponseCallback(const SessionHandle & handle, UpdateMaterialPropertyResponseCallback callback) Sets callback for UpdateMaterialProperty responses.
Result< void >	setUpdateMaterialPropertyCallback(const SessionHandle & handle, UpdateMaterialPropertyCallback callback) Sets callback for UpdateMaterialProperty requests.
Result< void >	setUpdateMaterialPropertiesBatchResponseCallback(const SessionHandle & handle, UpdateMaterialPropertiesBatchResponseCallback callback) Sets callback for UpdateMaterialPropertiesBatch responses.
Result< void >	setUpdateMaterialPropertiesBatchCallback(const SessionHandle & handle, UpdateMaterialPropertiesBatchCallback callback) Sets callback for UpdateMaterialPropertiesBatch requests.
Result< void >	setSetSceneEnabledResponseCallback(const SessionHandle & handle, SetSceneEnabledResponseCallback callback) Sets callback for SetSceneEnabledResponse messages.
Result< void >	setSetSceneEnabledCallback(const SessionHandle & handle, SetSceneEnabledCallback callback) Sets callback for SetSceneEnabledRequest messages.
Result< void >	setSceneSnapshotCallback(const SessionHandle & handle, SceneSnapshotCallback callback) Sets callback for SceneSnapshot messages.
Result< void >	setPropertyUpdateCallback(const SessionHandle & handle, PropertyUpdateCallback callback) Sets callback for PropertyUpdate batches.
Result< void >	setMeshMaterialBindingUpdateCallback(const SessionHandle & handle, NetworkSession::MeshMaterialBindingUpdateCallback callback) Sets callback for MeshMaterialBinding updates (clients receive broadcast).
Result< void >	setMeshMaterialBindingResponseCallback(const SessionHandle & handle, NetworkSession::MeshMaterialBindingResponseCallback callback) Sets callback for MeshMaterialBinding responses (client receives results).
Result< void >	setMeshMaterialBindingCallback(const SessionHandle & handle, NetworkSession::MeshMaterialBindingCallback callback) Sets callback for MeshMaterialBinding requests (server receives binding requests).
Result< void >	setMaterialUnsubscribeResponseCallback(const SessionHandle & handle, MaterialUnsubscribeResponseCallback callback) Sets callback for MaterialUnsubscribe responses.
Result< void >	setMaterialUnsubscribeCallback(const SessionHandle & handle, MaterialUnsubscribeCallback callback) Sets callback for MaterialUnsubscribe requests.
Result< void >	setMaterialSubscribeResponseCallback(const SessionHandle & handle, MaterialSubscribeResponseCallback callback) Sets callback for MaterialSubscribe responses.
Result< void >	setMaterialSubscribeCallback(const SessionHandle & handle, MaterialSubscribeCallback callback) Sets callback for MaterialSubscribe requests.
Result< void >	setMaterialResolvedCallback(const SessionHandle & handle, MaterialResolvedCallback callback) Sets callback for MaterialResolved notifications (server push of material data).
Result< void >	setMaterialPropertyUpdateCallback(const SessionHandle & handle, MaterialPropertyUpdateCallback callback) Sets callback for MaterialPropertyUpdate broadcasts (from other clients).
Result< void >	setHeartbeatCallback(const SessionHandle & handle, HeartbeatCallback callback) Sets callback for Heartbeat messages.
Result< void >	setHandshakeCallback(const SessionHandle & handle, HandshakeCallback callback) Sets callback for Handshake completion (server-side).
Result< void >	setGetShaderResponseCallback(const SessionHandle & handle, NetworkSession::GetShaderResponseCallback callback) Sets callback for GetShader responses (client receives shader data).
Result< void >	setGetShaderCallback(const SessionHandle & handle, NetworkSession::GetShaderCallback callback) Sets callback for GetShader requests (server receives shader queries).
Result< void >	setGetMaterialResponseCallback(const SessionHandle & handle, GetMaterialResponseCallback callback) Sets callback for GetMaterial responses.
Result< void >	setGetMaterialCallback(const SessionHandle & handle, GetMaterialCallback callback) Sets callback for GetMaterial requests.
Result< void >	setErrorCallback(const SessionHandle & handle, ErrorCallback callback) Sets callback for error conditions.
Result< void >	setEntityDestroyedCallback(const SessionHandle & handle, EntityDestroyedCallback callback) Sets callback for EntityDestroyed messages.
Result< void >	setEntityCreatedCallback(const SessionHandle & handle, EntityCreatedCallback callback) Sets callback for EntityCreated messages.
Result< void >	setDisconnectCallback(const SessionHandle & handle, NetworkSession::DisconnectCallback callback) Sets callback for connection disconnect/failure.
Result< void >	setDestroySceneResponseCallback(const SessionHandle & handle, DestroySceneResponseCallback callback) Sets callback for DestroySceneResponse messages.
Result< void >	setDestroySceneCallback(const SessionHandle & handle, DestroySceneCallback callback) Sets callback for DestroySceneRequest messages.
Result< void >	setCreateSceneResponseCallback(const SessionHandle & handle, CreateSceneResponseCallback callback) Sets callback for CreateSceneResponse messages.
Result< void >	setCreateSceneCallback(const SessionHandle & handle, CreateSceneCallback callback) Sets callback for CreateSceneRequest messages.
Result< void >	setCreateMaterialResponseCallback(const SessionHandle & handle, CreateMaterialResponseCallback callback) Sets callback for CreateMaterial responses.
Result< void >	setCreateMaterialCallback(const SessionHandle & handle, CreateMaterialCallback callback) Sets callback for CreateMaterial requests.
Result< void >	setAssetWithdrawResponseCallback(const SessionHandle & handle, AssetWithdrawResponseCallback callback) Sets callback for AssetWithdrawResponse messages.
Result< void >	setAssetWithdrawCallback(const SessionHandle & handle, AssetWithdrawCallback callback) Sets callback for AssetWithdraw messages.
Result< void >	setAssetWithdrawAllResponseCallback(const SessionHandle & handle, AssetWithdrawAllResponseCallback callback) Sets callback for AssetWithdrawAllResponse messages.
Result< void >	setAssetWithdrawAllCallback(const SessionHandle & handle, AssetWithdrawAllCallback callback) Sets callback for AssetWithdrawAll messages.
Result< void >	setAssetUploadResponseCallback(const SessionHandle & handle, AssetUploadResponseCallback callback) Sets callback for AssetUploadResponse messages.
Result< void >	setAssetUploadCompleteResponseCallback(const SessionHandle & handle, AssetUploadCompleteResponseCallback callback) Sets callback for AssetUploadCompleteResponse messages.
Result< void >	setAssetUploadChunkResponseCallback(const SessionHandle & handle, AssetUploadChunkResponseCallback callback) Sets callback for AssetUploadChunkResponse messages.
Result< void >	setAssetUploadCancelResponseCallback(const SessionHandle & handle, AssetUploadCancelResponseCallback callback) Sets callback for AssetUploadCancelResponse messages.
Result< void >	setAssetUploadCallback(const SessionHandle & handle, AssetUploadCallback callback) Sets callback for AssetUpload messages.
Result< void >	setAssetUploadBeginResponseCallback(const SessionHandle & handle, AssetUploadBeginResponseCallback callback) Sets callback for AssetUploadBeginResponse messages.
Result< void >	setAssetResolveResponseCallback(const SessionHandle & handle, AssetResolveResponseCallback callback) Sets callback for AssetResolveResponse messages.
Result< void >	setAssetResolveCallback(const SessionHandle & handle, AssetResolveCallback callback) Sets callback for AssetResolve messages.
Result< void >	setAssetResolveBatchResponseCallback(const SessionHandle & handle, AssetResolveBatchResponseCallback callback) Sets callback for AssetResolveBatchResponse messages.
Result< void >	setAssetResolveBatchCallback(const SessionHandle & handle, AssetResolveBatchCallback callback) Sets callback for AssetResolveBatch messages.
Result< void >	setAssetProvideKeyResponseCallback(const SessionHandle & handle, AssetProvideKeyResponseCallback callback) Sets callback for AssetProvideKeyResponse messages.
Result< void >	setAssetProvideKeyCallback(const SessionHandle & handle, AssetProvideKeyCallback callback) Sets callback for AssetProvideKey messages.
Result< void >	setAssetMetadataResponseCallback(const SessionHandle & handle, NetworkSession::AssetMetadataResponseCallback callback) Sets callback for AssetMetadataResponse messages.
Result< void >	setAssetMetadataCallback(const SessionHandle & handle, NetworkSession::AssetMetadataCallback callback) Sets callback for AssetMetadataRequest messages.
Result< void >	setAssetFetchResponseCallback(const SessionHandle & handle, AssetFetchResponseCallback callback) Sets callback for AssetFetchResponse messages.
Result< void >	setAssetFetchCallback(const SessionHandle & handle, AssetFetchCallback callback) Sets callback for AssetFetch messages.
Result< void >	setAssetAdvertiseResponseCallback(const SessionHandle & handle, AssetAdvertiseResponseCallback callback) Sets callback for AssetAdvertiseResponse messages.
Result< void >	setAssetAdvertiseCallback(const SessionHandle & handle, AssetAdvertiseCallback callback) Sets callback for AssetAdvertise messages.
Result< void >	setAddEntityToSceneResponseCallback(const SessionHandle & handle, AddEntityToSceneResponseCallback callback) Sets callback for AddEntityToSceneResponse messages.
Result< void >	setAddEntityToSceneCallback(const SessionHandle & handle, AddEntityToSceneCallback callback) Sets callback for AddEntityToSceneRequest messages.
Result< void >	sendUpdateMaterialPropertyResponse(const SessionHandle & handle, bool success, uint64_t newVersion, const std::string & errorMessage) Sends UpdateMaterialPropertyResponse message.
Result< void >	sendUpdateMaterialPropertyRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, const std::string & propertyName, const PropertyValue & value, uint64_t requestId =0) Sends UpdateMaterialPropertyRequest message.
Result< void >	sendUpdateMaterialPropertiesBatchResponse(const SessionHandle & handle, bool success, uint64_t newVersion, const std::string & errorMessage) Sends UpdateMaterialPropertiesBatchResponse message.
Result< void >	sendUpdateMaterialPropertiesBatchRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, const std::vector< MaterialPropertyData > & properties, uint64_t requestId =0) Sends UpdateMaterialPropertiesBatchRequest message.
Result< void >	sendSetSceneEnabledResponse(const SessionHandle & handle, bool success, const std::string & errorMessage) Sends SetSceneEnabledResponse message.
Result< void >	sendSetSceneEnabledRequest(const SessionHandle & handle, uint64_t sceneId, bool enabled) Sends SetSceneEnabledRequest message.
Result< void >	sendSceneSnapshot(const SessionHandle & handle, const std::vector< uint8_t > & snapshotData) Sends SceneSnapshot message (called by handle.sendSceneSnapshot()).
Result< void >	sendPropertyUpdateBatch(const SessionHandle & handle, const std::vector< uint8_t > & batchData) Sends PropertyUpdateBatch message (called by handle.sendPropertyUpdateBatch()).
Result< void >	sendPropertyUpdate(const SessionHandle & handle, PropertyHash hash, PropertyType type, const PropertyValue & value) Sends PropertyUpdate message (called by handle.sendPropertyUpdate()).
Result< void >	sendMeshMaterialBindingUpdate(const SessionHandle & handle, uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > & materialIds, uint64_t originSessionId) Sends MeshMaterialBindingUpdate (broadcast).
Result< void >	sendMeshMaterialBindingResponse(const SessionHandle & handle, bool success, const std::string & errorMessage, uint64_t requestId =0) Sends MeshMaterialBindingResponse.
Result< void >	sendMeshMaterialBindingRequest(const SessionHandle & handle, uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > & materialIds, uint64_t requestId =0) Sends MeshMaterialBindingRequest.
Result< void >	sendMaterialUnsubscribeResponse(const SessionHandle & handle, bool success, const std::string & errorMessage) Sends MaterialUnsubscribeResponse message.
Result< void >	sendMaterialUnsubscribeRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0) Sends MaterialUnsubscribeRequest message.
Result< void >	sendMaterialSubscribeResponse(const SessionHandle & handle, bool success, const MaterialAssetData & material, const std::string & errorMessage, uint64_t requestId =0) Sends MaterialSubscribeResponse message.
Result< void >	sendMaterialSubscribeRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0) Sends MaterialSubscribeRequest message.
Result< void >	sendMaterialResolved(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, const MaterialAssetData & material) Sends MaterialResolved notification.
Result< void >	sendMaterialPropertyUpdate(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, const std::string & propertyName, const PropertyValue & value, uint64_t newVersion, uint64_t originSessionId) Sends MaterialPropertyUpdate broadcast message.
Result< void >	sendHeartbeat(const SessionHandle & handle) Sends Heartbeat message (called by handle.sendHeartbeat()).
Result< void >	sendGetShaderResponse(const SessionHandle & handle, const NetworkSession::GetShaderResponseData & response, uint64_t requestId =0) Sends GetShaderResponse (server responds with shader data).
Result< void >	sendGetShaderRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & shaderAssetId, uint64_t requestId =0) Sends GetShaderRequest (client requests shader info).
Result< void >	sendGetMaterialResponse(const SessionHandle & handle, bool success, const MaterialAssetData & material, const std::string & errorMessage) Sends GetMaterialResponse message.
Result< void >	sendGetMaterialRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0) Sends GetMaterialRequest message.
Result< void >	sendEntityDestroyed(const SessionHandle & handle, uint64_t entityId) Sends EntityDestroyed message (called by handle.sendEntityDestroyed()).
Result< void >	sendEntityCreated(const SessionHandle & handle, uint64_t entityId, const std::string & appId, const std::string & typeName, uint64_t parentId, const std::vector< NetworkSession::ComponentGroupData > & components ={}, uint64_t targetSceneId =0, const std::string & entityName ="") Sends EntityCreated message (called by handle.sendEntityCreated()).
Result< void >	sendDestroySceneResponse(const SessionHandle & handle, bool success, const std::string & errorMessage) Sends DestroySceneResponse message.
Result< void >	sendDestroySceneRequest(const SessionHandle & handle, uint64_t sceneId) Sends DestroySceneRequest message.
Result< void >	sendCreateSceneResponse(const SessionHandle & handle, bool success, uint64_t sceneId, const std::string & errorMessage) Sends CreateSceneResponse message.
Result< void >	sendCreateSceneRequest(const SessionHandle & handle, const std::string & sceneName, bool transient) Sends CreateSceneRequest message.
Result< void >	sendCreateMaterialResponse(const SessionHandle & handle, bool success, const std::array< uint8_t, 32 > & materialId, const std::string & errorMessage, uint64_t requestId =0) Sends CreateMaterialResponse message.
Result< void >	sendCreateMaterialRequest(const SessionHandle & handle, const MaterialAssetData & material, uint64_t requestId =0) Sends CreateMaterialRequest message.
Result< void >	sendComponentRemoved(const SessionHandle & handle, uint64_t entityId, ComponentTypeHash typeHash) Sends ComponentRemoved message (called by handle.sendComponentRemoved()).
Result< void >	sendComponentAdded(const SessionHandle & handle, uint64_t entityId, const NetworkSession::ComponentGroupData & component) Sends ComponentAdded message (called by handle.sendComponentAdded()).
Result< void >	sendAssetWithdrawAll(const SessionHandle & handle, const std::string & appId, uint64_t requestId =0) Sends AssetWithdrawAll request.
Result< void >	sendAssetWithdraw(const SessionHandle & handle, const std::vector< std::array< uint8_t, 32 > > & assetIds, uint64_t requestId =0) Sends AssetWithdraw request.
Result< void >	sendAssetUploadResponse(const SessionHandle & handle, bool success, const std::array< uint8_t, 32 > & assetId, const std::string & uri, const std::string & errorMessage, uint64_t requestId =0) Sends AssetUploadResponse message.
Result< void >	sendAssetUploadComplete(const SessionHandle & handle, const NetworkSession::AssetUploadCompleteData & data) Completes a chunked upload session.
Result< void >	sendAssetUploadChunk(const SessionHandle & handle, const NetworkSession::AssetUploadChunkData & data) Sends a chunk during chunked upload.
Result< void >	sendAssetUploadCancel(const SessionHandle & handle, const std::array< uint8_t, 16 > & uploadId) Cancels an in-progress chunked upload.
Result< void >	sendAssetUploadBegin(const SessionHandle & handle, const NetworkSession::AssetUploadBeginData & data) Begins a chunked upload session.
Result< void >	sendAssetUpload(const SessionHandle & handle, const std::string & appId, const std::vector< uint8_t > & data, uint8_t contentType, bool persistent, uint64_t requestId =0) Sends AssetUpload request.
Result< void >	sendAssetUpload(const SessionHandle & handle, const std::string & appId, const std::vector< uint8_t > & data, uint8_t contentType, bool persistent, uint64_t requestId, const NetworkSession::AssetMetadataData & metadata) Sends AssetUpload request with metadata.
Result< void >	sendAssetResolveResponse(const SessionHandle & handle, bool found, const AssetEntryData & entry, bool hasKey, const std::array< uint8_t, 32 > & key, uint8_t deliveryMethod, uint64_t requestId =0) Sends AssetResolveResponse message.
Result< void >	sendAssetResolveBatch(const SessionHandle & handle, const std::vector< std::array< uint8_t, 32 > > & assetIds, uint64_t requestId =0) Sends AssetResolveBatch request.
Result< void >	sendAssetResolve(const SessionHandle & handle, const std::array< uint8_t, 32 > & assetId, uint64_t requestId =0) Sends AssetResolve request.
Result< void >	sendAssetProvideKey(const SessionHandle & handle, const std::array< uint8_t, 32 > & assetId, const std::array< uint8_t, 32 > & key, uint64_t requestId =0) Sends AssetProvideKey request.
Result< void >	sendAssetMetadataResponse(const SessionHandle & handle, bool found, const NetworkSession::AssetMetadataData & metadata, uint64_t requestId =0) Sends AssetMetadataResponse message.
Result< void >	sendAssetMetadataRequest(const SessionHandle & handle, const std::array< uint8_t, 32 > & assetId, uint64_t requestId =0) Sends AssetMetadataRequest message.
Result< void >	sendAssetFetchResponse(const SessionHandle & handle, bool found, const std::vector< uint8_t > & data, const std::string & errorMessage, uint64_t requestId =0) Sends AssetFetchResponse message.
Result< void >	sendAssetFetch(const SessionHandle & handle, const std::array< uint8_t, 32 > & assetId, uint64_t requestId =0) Sends AssetFetch request.
Result< void >	sendAssetAdvertiseResponse(const SessionHandle & handle, bool success, const std::string & errorMessage, uint64_t requestId =0) Sends AssetAdvertiseResponse message.
Result< void >	sendAssetAdvertise(const SessionHandle & handle, const std::string & appId, const std::vector< NetworkSession::AssetEntryData > & entries, uint64_t requestId =0) Sends AssetAdvertise request.
Result< void >	sendAddEntityToSceneResponse(const SessionHandle & handle, bool success, const std::string & errorMessage) Sends AddEntityToSceneResponse message.
Result< void >	sendAddEntityToSceneRequest(const SessionHandle & handle, uint64_t entityId, uint64_t sceneId) Sends AddEntityToSceneRequest message.
Result< void >	performHandshake(const SessionHandle & handle, const std::string & clientType, const std::string & clientId) Initiates handshake (called by handle.performHandshake()).
SessionManager &	operator=(const SessionManager & ) =delete
Result< void >	openChannel(const SessionHandle & handle, const std::string & channel) Open a named data channel for bulk data transfer.
bool	isValidHandle(const SessionHandle & handle) const Validates handle (called by handle.valid()).
bool	isConnected(const SessionHandle & handle) const Checks if connected (called by handle.isConnected()).
ComponentSchemaRegistry *	getSchemaRegistry() const Get schema registry (if configured).
PropertyRegistry &	getPropertyRegistry(const SessionHandle & handle) Gets property registry (called by handle.getPropertyRegistry()).
const PropertyRegistry &	getPropertyRegistry(const SessionHandle & handle) const Gets property registry const (called by handle.getPropertyRegistry()).
ConnectionStats	getConnectionStats(const SessionHandle & handle) const Gets connection stats (called by handle.getConnectionStats()).
ConnectionState	getConnectionState(const SessionHandle & handle) const Gets connection state (called by handle.getConnectionState()).
ConnectionHandle	getConnection(const SessionHandle & handle) const Gets connection handle (called by handle.getConnection()).
void	flushAllPropertyBatches() Flush property update batches for all connected sessions.
Result< void >	destroySession(const SessionHandle & handle) Destroys a session and returns its slot to the free list.
SessionHandle	createSession(ConnectionHandle connection, PropertyRegistry * externalRegistry =nullptr) Creates a new session wrapping the given connection.
virtual const char *	className() const override Runtime class name for diagnostics and reflection.
virtual uint64_t	classHash() const override Stable type hash for cross-language identification.
size_t	capacity() const Gets maximum capacity.
void	broadcastSchemaUnpublish(ComponentTypeHash typeHash) Broadcast schema unpublish notification to all connected sessions.
void	broadcastSchemaAdvertisement(ComponentTypeHash typeHash, const ComponentSchema & schema) Broadcast schema advertisement to all connected sessions.
void	broadcastMaterialPropertyUpdate(const std::array< uint8_t, 32 > & materialId, const std::string & propertyName, const PropertyValue & value, uint64_t newVersion, uint64_t originSessionId, const std::vector< uint64_t > & subscribedSessionIds) Broadcast material property update to all subscribed sessions except origin.
size_t	activeCount() const Gets active session count.
	SessionManager(ConnectionManager * connectionManager, size_t capacity, ComponentSchemaRegistry * schemaRegistry =nullptr) Constructs session manager with specified capacity.
	SessionManager(const SessionManager & ) =delete

Friends

	Name
class	SessionHandle

Additional inherited members

Protected Classes inherited from EntropyEngine::Core::EntropyObject

	Name
struct	HandleCore Optional handle identity stamped by an owner/registry.

Public Functions inherited from EntropyEngine::Core::EntropyObject

	Name
virtual	~EntropyObject() =default
virtual const TypeSystem::TypeInfo *	typeInfo() const Optional richer type information; may be null.
bool	tryRetain() const Attempts to retain only if the object is still alive.
void	retain() const Increments the reference count.
void	release() const Decrements the reference count and deletes when it reaches zero.
uint32_t	refCount() const Current reference count (approximate under contention).
bool	hasHandle() const
template <class OwnerT > OwnerT *	handleOwnerAs() const Returns the stamped owner pointer cast to the requested type.
const void *	handleOwner() const
uint32_t	handleIndex() const
uint64_t	handleId() const
uint32_t	handleGeneration() const
WeakControlBlock *	getWeakControlBlock() const Lazily retrieves or creates the weak control block.
virtual std::string	description() const Long-form description; defaults to toString().
virtual std::string	debugString() const Debug-oriented string including refcount and handle when present.
	EntropyObject() =default
	EntropyObject(EntropyObject && ) =delete
	EntropyObject(const EntropyObject & ) =delete

Protected Functions inherited from EntropyEngine::Core::EntropyObject

	Name
void	_setHandleIdentity(void * owner, uint32_t index, uint32_t generation)
void	_clearHandleIdentity()

Protected Attributes inherited from EntropyEngine::Core::EntropyObject

	Name
std::atomic< WeakControlBlock * >	_weakBlock Lazily allocated control block for weak refs.
std::atomic< uint32_t >	_refCount Thread-safe retain/release counter.
struct EntropyEngine::Core::EntropyObject::HandleCore	_handle

Friends inherited from EntropyEngine::Core::EntropyObject

	Name
struct	HandleAccess

Detailed Description

class EntropyEngine::Networking::SessionManager;

Slot-based session manager for protocol-level operations.

SessionManager follows the WorkContractGroup pattern - it owns session slots and returns generation-stamped handles. Builds on ConnectionManager to provide protocol-level messaging (EntityCreated, PropertyUpdate, etc.).

Handle lifecycle:

1. Create session via createSession(connectionHandle)
2. Returns SessionHandle stamped with (manager + index + generation)
3. Use handle for protocol operations
4. Handle becomes invalid after release

Session structure:

• Each session wraps a ConnectionHandle
• Sessions maintain PropertyRegistry for entity tracking
• Callbacks can be set for incoming protocol messages

Thread Safety: All public methods are thread-safe. Operations use minimal per-slot locking for session access.

ConnectionManager connMgr(1024);
SessionManager sessMgr(&connMgr, 512);

auto conn = connMgr.openLocalConnection("/tmp/entropy.sock");
conn.connect().wait();

auto sess = sessMgr.createSession(conn);
sess.sendEntityCreated(entityId, appId, typeName, parentId);

// Set up callbacks
sessMgr.setEntityCreatedCallback(sess, [](auto...) { ... });

Public Types Documentation

using UpdateMaterialPropertyResponseCallback

using EntropyEngine::Networking::SessionManager::UpdateMaterialPropertyResponseCallback = NetworkSession::UpdateMaterialPropertyResponseCallback;

using UpdateMaterialPropertyCallback

using EntropyEngine::Networking::SessionManager::UpdateMaterialPropertyCallback = NetworkSession::UpdateMaterialPropertyCallback;

using UpdateMaterialPropertiesBatchResponseCallback

using EntropyEngine::Networking::SessionManager::UpdateMaterialPropertiesBatchResponseCallback = NetworkSession::UpdateMaterialPropertiesBatchResponseCallback;

using UpdateMaterialPropertiesBatchCallback

using EntropyEngine::Networking::SessionManager::UpdateMaterialPropertiesBatchCallback = NetworkSession::UpdateMaterialPropertiesBatchCallback;

using SetSceneEnabledResponseCallback

using EntropyEngine::Networking::SessionManager::SetSceneEnabledResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using SetSceneEnabledCallback

using EntropyEngine::Networking::SessionManager::SetSceneEnabledCallback = std::function<void(uint64_t sceneId, bool enabled)>;

using SceneSnapshotCallback

using EntropyEngine::Networking::SessionManager::SceneSnapshotCallback = std::function<void(const std::vector<uint8_t>& data)>;

using PropertyUpdateCallback

using EntropyEngine::Networking::SessionManager::PropertyUpdateCallback = std::function<void(const std::vector<uint8_t>& data)>;

using PropertyRegistrationInfo

using EntropyEngine::Networking::SessionManager::PropertyRegistrationInfo = NetworkSession::PropertyRegistrationInfo;

using MaterialUnsubscribeResponseCallback

using EntropyEngine::Networking::SessionManager::MaterialUnsubscribeResponseCallback = NetworkSession::MaterialUnsubscribeResponseCallback;

using MaterialUnsubscribeCallback

using EntropyEngine::Networking::SessionManager::MaterialUnsubscribeCallback = NetworkSession::MaterialUnsubscribeCallback;

using MaterialSubscribeResponseCallback

using EntropyEngine::Networking::SessionManager::MaterialSubscribeResponseCallback = NetworkSession::MaterialSubscribeResponseCallback;

using MaterialSubscribeCallback

using EntropyEngine::Networking::SessionManager::MaterialSubscribeCallback = NetworkSession::MaterialSubscribeCallback;

using MaterialResolvedCallback

using EntropyEngine::Networking::SessionManager::MaterialResolvedCallback = NetworkSession::MaterialResolvedCallback;

using MaterialPropertyUpdateCallback

using EntropyEngine::Networking::SessionManager::MaterialPropertyUpdateCallback = NetworkSession::MaterialPropertyUpdateCallback;

using MaterialPropertyData

using EntropyEngine::Networking::SessionManager::MaterialPropertyData = NetworkSession::MaterialPropertyData;

using MaterialAssetData

using EntropyEngine::Networking::SessionManager::MaterialAssetData = NetworkSession::MaterialAssetData;

using HeartbeatCallback

using EntropyEngine::Networking::SessionManager::HeartbeatCallback = std::function<void(uint64_t timestamp)>;

using HandshakeCallback

using EntropyEngine::Networking::SessionManager::HandshakeCallback = std::function<void(const std::string& clientType, const std::string& clientId)>;

using GetMaterialResponseCallback

using EntropyEngine::Networking::SessionManager::GetMaterialResponseCallback = NetworkSession::GetMaterialResponseCallback;

using GetMaterialCallback

using EntropyEngine::Networking::SessionManager::GetMaterialCallback = NetworkSession::GetMaterialCallback;

using ErrorCallback

using EntropyEngine::Networking::SessionManager::ErrorCallback = std::function<void(NetworkError error, const std::string& message)>;

using EntityDestroyedCallback

using EntropyEngine::Networking::SessionManager::EntityDestroyedCallback = std::function<void(uint64_t entityId)>;

using EntityCreatedCallback

using EntropyEngine::Networking::SessionManager::EntityCreatedCallback = NetworkSession::EntityCreatedCallback;

using DestroySceneResponseCallback

using EntropyEngine::Networking::SessionManager::DestroySceneResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using DestroySceneCallback

using EntropyEngine::Networking::SessionManager::DestroySceneCallback = std::function<void(uint64_t sceneId)>;

using CreateSceneResponseCallback

using EntropyEngine::Networking::SessionManager::CreateSceneResponseCallback =
std::function<void(bool success, uint64_t sceneId, const std::string& errorMessage)>;

using CreateSceneCallback

using EntropyEngine::Networking::SessionManager::CreateSceneCallback = std::function<void(const std::string& sceneName, bool transient)>;

using CreateMaterialResponseCallback

using EntropyEngine::Networking::SessionManager::CreateMaterialResponseCallback = NetworkSession::CreateMaterialResponseCallback;

using CreateMaterialCallback

using EntropyEngine::Networking::SessionManager::CreateMaterialCallback = NetworkSession::CreateMaterialCallback;

using ComponentGroupData

using EntropyEngine::Networking::SessionManager::ComponentGroupData = NetworkSession::ComponentGroupData;

using AssetWithdrawResponseCallback

using EntropyEngine::Networking::SessionManager::AssetWithdrawResponseCallback =
std::function<void(uint64_t requestId, bool success, uint32_t removedCount, const std::string& errorMessage)>;

using AssetWithdrawCallback

using EntropyEngine::Networking::SessionManager::AssetWithdrawCallback =
std::function<void(const std::vector<std::array<uint8_t, 32>>& assetIds, uint64_t requestId)>;

using AssetWithdrawAllResponseCallback

using EntropyEngine::Networking::SessionManager::AssetWithdrawAllResponseCallback =
std::function<void(uint64_t requestId, bool success, uint32_t removedCount, const std::string& errorMessage)>;

using AssetWithdrawAllCallback

using EntropyEngine::Networking::SessionManager::AssetWithdrawAllCallback = std::function<void(const std::string& appId, uint64_t requestId)>;

using AssetUploadResponseCallback

using EntropyEngine::Networking::SessionManager::AssetUploadResponseCallback =
std::function<void(uint64_t requestId, bool success, const std::array<uint8_t, 32>& assetId,
                   const std::string& uri, const std::string& errorMessage)>;

using AssetUploadCompleteResponseCallback

using EntropyEngine::Networking::SessionManager::AssetUploadCompleteResponseCallback =
std::function<void(const NetworkSession::AssetUploadCompleteResponseData& data)>;

using AssetUploadChunkResponseCallback

using EntropyEngine::Networking::SessionManager::AssetUploadChunkResponseCallback =
std::function<void(const NetworkSession::AssetUploadChunkResponseData& data)>;

using AssetUploadCancelResponseCallback

using EntropyEngine::Networking::SessionManager::AssetUploadCancelResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using AssetUploadCallback

using EntropyEngine::Networking::SessionManager::AssetUploadCallback =
std::function<void(const std::string& appId, const std::vector<uint8_t>& data, uint8_t contentType,
                   bool persistent, uint64_t requestId, const NetworkSession::AssetMetadataData& metadata)>;

using AssetUploadBeginResponseCallback

using EntropyEngine::Networking::SessionManager::AssetUploadBeginResponseCallback =
std::function<void(const NetworkSession::AssetUploadBeginResponseData& data)>;

using AssetResolveResponseData

using EntropyEngine::Networking::SessionManager::AssetResolveResponseData = NetworkSession::AssetResolveResponseData;

using AssetResolveResponseCallback

using EntropyEngine::Networking::SessionManager::AssetResolveResponseCallback =
std::function<void(uint64_t requestId, const AssetResolveResponseData& response)>;

using AssetResolveCallback

using EntropyEngine::Networking::SessionManager::AssetResolveCallback = std::function<void(const std::array<uint8_t, 32>& assetId, uint64_t requestId)>;

using AssetResolveBatchResponseCallback

using EntropyEngine::Networking::SessionManager::AssetResolveBatchResponseCallback =
std::function<void(uint64_t requestId, const std::vector<AssetResolveResponseData>& responses)>;

using AssetResolveBatchCallback

using EntropyEngine::Networking::SessionManager::AssetResolveBatchCallback =
std::function<void(const std::vector<std::array<uint8_t, 32>>& assetIds, uint64_t requestId)>;

using AssetProvideKeyResponseCallback

using EntropyEngine::Networking::SessionManager::AssetProvideKeyResponseCallback =
std::function<void(uint64_t requestId, bool success, const std::string& errorMessage)>;

using AssetProvideKeyCallback

using EntropyEngine::Networking::SessionManager::AssetProvideKeyCallback = std::function<void(const std::array<uint8_t, 32>& assetId,
                                                      const std::array<uint8_t, 32>& key, uint64_t requestId)>;

using AssetFetchResponseCallback

using EntropyEngine::Networking::SessionManager::AssetFetchResponseCallback = std::function<void(
       uint64_t requestId, bool found, const std::vector<uint8_t>& data, const std::string& errorMessage)>;

using AssetFetchCallback

using EntropyEngine::Networking::SessionManager::AssetFetchCallback = std::function<void(const std::array<uint8_t, 32>& assetId, uint64_t requestId)>;

using AssetEntryData

using EntropyEngine::Networking::SessionManager::AssetEntryData = NetworkSession::AssetEntryData;

using AssetAdvertiseResponseCallback

using EntropyEngine::Networking::SessionManager::AssetAdvertiseResponseCallback =
std::function<void(uint64_t requestId, bool success, const std::string& errorMessage)>;

using AssetAdvertiseCallback

using EntropyEngine::Networking::SessionManager::AssetAdvertiseCallback =
std::function<void(const std::string& appId, const std::vector<AssetEntryData>& entries, uint64_t requestId)>;

using AddEntityToSceneResponseCallback

using EntropyEngine::Networking::SessionManager::AddEntityToSceneResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using AddEntityToSceneCallback

using EntropyEngine::Networking::SessionManager::AddEntityToSceneCallback = std::function<void(uint64_t entityId, uint64_t sceneId)>;

Public Functions Documentation

function ~SessionManager

~SessionManager()

function toString

virtual std::string toString() const override

Human-readable short string (class@ptr by default).

Reimplements: EntropyEngine::Core::EntropyObject::toString

function supportsMultipleChannels

bool supportsMultipleChannels(
    const SessionHandle & handle
)

Check if session’s connection supports multiple data channels.

function setUpdateMaterialPropertyResponseCallback

Result< void > setUpdateMaterialPropertyResponseCallback(
    const SessionHandle & handle,
    UpdateMaterialPropertyResponseCallback callback
)

Sets callback for UpdateMaterialProperty responses.

function setUpdateMaterialPropertyCallback

Result< void > setUpdateMaterialPropertyCallback(
    const SessionHandle & handle,
    UpdateMaterialPropertyCallback callback
)

Sets callback for UpdateMaterialProperty requests.

function setUpdateMaterialPropertiesBatchResponseCallback

Result< void > setUpdateMaterialPropertiesBatchResponseCallback(
    const SessionHandle & handle,
    UpdateMaterialPropertiesBatchResponseCallback callback
)

Sets callback for UpdateMaterialPropertiesBatch responses.

function setUpdateMaterialPropertiesBatchCallback

Result< void > setUpdateMaterialPropertiesBatchCallback(
    const SessionHandle & handle,
    UpdateMaterialPropertiesBatchCallback callback
)

Sets callback for UpdateMaterialPropertiesBatch requests.

function setSetSceneEnabledResponseCallback

Result< void > setSetSceneEnabledResponseCallback(
    const SessionHandle & handle,
    SetSceneEnabledResponseCallback callback
)

Sets callback for SetSceneEnabledResponse messages.

Parameters:

• handle Session handle
• callback Callback function invoked when SetSceneEnabledResponse is received

Return: Result indicating success or failure

function setSetSceneEnabledCallback

Result< void > setSetSceneEnabledCallback(
    const SessionHandle & handle,
    SetSceneEnabledCallback callback
)

Sets callback for SetSceneEnabledRequest messages.

Parameters:

• handle Session handle
• callback Callback function invoked when SetSceneEnabledRequest is received

Return: Result indicating success or failure

function setSceneSnapshotCallback

Result< void > setSceneSnapshotCallback(
    const SessionHandle & handle,
    SceneSnapshotCallback callback
)

Sets callback for SceneSnapshot messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setPropertyUpdateCallback

Result< void > setPropertyUpdateCallback(
    const SessionHandle & handle,
    PropertyUpdateCallback callback
)

Sets callback for PropertyUpdate batches.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setMeshMaterialBindingUpdateCallback

Result< void > setMeshMaterialBindingUpdateCallback(
    const SessionHandle & handle,
    NetworkSession::MeshMaterialBindingUpdateCallback callback
)

Sets callback for MeshMaterialBinding updates (clients receive broadcast).

function setMeshMaterialBindingResponseCallback

Result< void > setMeshMaterialBindingResponseCallback(
    const SessionHandle & handle,
    NetworkSession::MeshMaterialBindingResponseCallback callback
)

Sets callback for MeshMaterialBinding responses (client receives results).

function setMeshMaterialBindingCallback

Result< void > setMeshMaterialBindingCallback(
    const SessionHandle & handle,
    NetworkSession::MeshMaterialBindingCallback callback
)

Sets callback for MeshMaterialBinding requests (server receives binding requests).

function setMaterialUnsubscribeResponseCallback

Result< void > setMaterialUnsubscribeResponseCallback(
    const SessionHandle & handle,
    MaterialUnsubscribeResponseCallback callback
)

Sets callback for MaterialUnsubscribe responses.

function setMaterialUnsubscribeCallback

Result< void > setMaterialUnsubscribeCallback(
    const SessionHandle & handle,
    MaterialUnsubscribeCallback callback
)

Sets callback for MaterialUnsubscribe requests.

function setMaterialSubscribeResponseCallback

Result< void > setMaterialSubscribeResponseCallback(
    const SessionHandle & handle,
    MaterialSubscribeResponseCallback callback
)

Sets callback for MaterialSubscribe responses.

function setMaterialSubscribeCallback

Result< void > setMaterialSubscribeCallback(
    const SessionHandle & handle,
    MaterialSubscribeCallback callback
)

Sets callback for MaterialSubscribe requests.

function setMaterialResolvedCallback

Result< void > setMaterialResolvedCallback(
    const SessionHandle & handle,
    MaterialResolvedCallback callback
)

Sets callback for MaterialResolved notifications (server push of material data).

function setMaterialPropertyUpdateCallback

Result< void > setMaterialPropertyUpdateCallback(
    const SessionHandle & handle,
    MaterialPropertyUpdateCallback callback
)

Sets callback for MaterialPropertyUpdate broadcasts (from other clients).

function setHeartbeatCallback

Result< void > setHeartbeatCallback(
    const SessionHandle & handle,
    HeartbeatCallback callback
)

Sets callback for Heartbeat messages.

Parameters:

• handle Session handle
• callback Callback function invoked with heartbeat timestamp

Return: Result indicating success or failure

Callback is invoked when a heartbeat is received from the peer. Server-side uses this to track session liveness for timeout detection.

function setHandshakeCallback

Result< void > setHandshakeCallback(
    const SessionHandle & handle,
    HandshakeCallback callback
)

Sets callback for Handshake completion (server-side).

Parameters:

• handle Session handle
• callback Callback function invoked when handshake completes

Return: Result indicating success or failure

function setGetShaderResponseCallback

Result< void > setGetShaderResponseCallback(
    const SessionHandle & handle,
    NetworkSession::GetShaderResponseCallback callback
)

Sets callback for GetShader responses (client receives shader data).

function setGetShaderCallback

Result< void > setGetShaderCallback(
    const SessionHandle & handle,
    NetworkSession::GetShaderCallback callback
)

Sets callback for GetShader requests (server receives shader queries).

function setGetMaterialResponseCallback

Result< void > setGetMaterialResponseCallback(
    const SessionHandle & handle,
    GetMaterialResponseCallback callback
)

Sets callback for GetMaterial responses.

function setGetMaterialCallback

Result< void > setGetMaterialCallback(
    const SessionHandle & handle,
    GetMaterialCallback callback
)

Sets callback for GetMaterial requests.

function setErrorCallback

Result< void > setErrorCallback(
    const SessionHandle & handle,
    ErrorCallback callback
)

Sets callback for error conditions.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setEntityDestroyedCallback

Result< void > setEntityDestroyedCallback(
    const SessionHandle & handle,
    EntityDestroyedCallback callback
)

Sets callback for EntityDestroyed messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setEntityCreatedCallback

Result< void > setEntityCreatedCallback(
    const SessionHandle & handle,
    EntityCreatedCallback callback
)

Sets callback for EntityCreated messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

Callback is invoked when remote peer sends EntityCreated message.

function setDisconnectCallback

Result< void > setDisconnectCallback(
    const SessionHandle & handle,
    NetworkSession::DisconnectCallback callback
)

Sets callback for connection disconnect/failure.

Parameters:

• handle Session handle
• callback Callback function invoked with state and reason

Return: Result indicating success or failure

Called immediately when connection dies (broken pipe, EOF, etc). Enables immediate session cleanup for local IPC instead of waiting for heartbeat timeout.

function setDestroySceneResponseCallback

Result< void > setDestroySceneResponseCallback(
    const SessionHandle & handle,
    DestroySceneResponseCallback callback
)

Sets callback for DestroySceneResponse messages.

Parameters:

• handle Session handle
• callback Callback function invoked when DestroySceneResponse is received

Return: Result indicating success or failure

function setDestroySceneCallback

Result< void > setDestroySceneCallback(
    const SessionHandle & handle,
    DestroySceneCallback callback
)

Sets callback for DestroySceneRequest messages.

Parameters:

• handle Session handle
• callback Callback function invoked when DestroySceneRequest is received

Return: Result indicating success or failure

function setCreateSceneResponseCallback

Result< void > setCreateSceneResponseCallback(
    const SessionHandle & handle,
    CreateSceneResponseCallback callback
)

Sets callback for CreateSceneResponse messages.

Parameters:

• handle Session handle
• callback Callback function invoked when CreateSceneResponse is received

Return: Result indicating success or failure

function setCreateSceneCallback

Result< void > setCreateSceneCallback(
    const SessionHandle & handle,
    CreateSceneCallback callback
)

Sets callback for CreateSceneRequest messages.

Parameters:

• handle Session handle
• callback Callback function invoked when CreateSceneRequest is received

Return: Result indicating success or failure

function setCreateMaterialResponseCallback

Result< void > setCreateMaterialResponseCallback(
    const SessionHandle & handle,
    CreateMaterialResponseCallback callback
)

Sets callback for CreateMaterial responses.

function setCreateMaterialCallback

Result< void > setCreateMaterialCallback(
    const SessionHandle & handle,
    CreateMaterialCallback callback
)

Sets callback for CreateMaterial requests.

Parameters:

• handle Session handle
• callback Callback function invoked when CreateMaterialRequest is received

Return: Result indicating success or failure

function setAssetWithdrawResponseCallback

Result< void > setAssetWithdrawResponseCallback(
    const SessionHandle & handle,
    AssetWithdrawResponseCallback callback
)

Sets callback for AssetWithdrawResponse messages.

function setAssetWithdrawCallback

Result< void > setAssetWithdrawCallback(
    const SessionHandle & handle,
    AssetWithdrawCallback callback
)

Sets callback for AssetWithdraw messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetWithdrawAllResponseCallback

Result< void > setAssetWithdrawAllResponseCallback(
    const SessionHandle & handle,
    AssetWithdrawAllResponseCallback callback
)

Sets callback for AssetWithdrawAllResponse messages.

function setAssetWithdrawAllCallback

Result< void > setAssetWithdrawAllCallback(
    const SessionHandle & handle,
    AssetWithdrawAllCallback callback
)

Sets callback for AssetWithdrawAll messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetUploadResponseCallback

Result< void > setAssetUploadResponseCallback(
    const SessionHandle & handle,
    AssetUploadResponseCallback callback
)

Sets callback for AssetUploadResponse messages.

function setAssetUploadCompleteResponseCallback

Result< void > setAssetUploadCompleteResponseCallback(
    const SessionHandle & handle,
    AssetUploadCompleteResponseCallback callback
)

Sets callback for AssetUploadCompleteResponse messages.

function setAssetUploadChunkResponseCallback

Result< void > setAssetUploadChunkResponseCallback(
    const SessionHandle & handle,
    AssetUploadChunkResponseCallback callback
)

Sets callback for AssetUploadChunkResponse messages.

function setAssetUploadCancelResponseCallback

Result< void > setAssetUploadCancelResponseCallback(
    const SessionHandle & handle,
    AssetUploadCancelResponseCallback callback
)

Sets callback for AssetUploadCancelResponse messages.

function setAssetUploadCallback

Result< void > setAssetUploadCallback(
    const SessionHandle & handle,
    AssetUploadCallback callback
)

Sets callback for AssetUpload messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetUploadBeginResponseCallback

Result< void > setAssetUploadBeginResponseCallback(
    const SessionHandle & handle,
    AssetUploadBeginResponseCallback callback
)

Sets callback for AssetUploadBeginResponse messages.

function setAssetResolveResponseCallback

Result< void > setAssetResolveResponseCallback(
    const SessionHandle & handle,
    AssetResolveResponseCallback callback
)

Sets callback for AssetResolveResponse messages.

function setAssetResolveCallback

Result< void > setAssetResolveCallback(
    const SessionHandle & handle,
    AssetResolveCallback callback
)

Sets callback for AssetResolve messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetResolveBatchResponseCallback

Result< void > setAssetResolveBatchResponseCallback(
    const SessionHandle & handle,
    AssetResolveBatchResponseCallback callback
)

Sets callback for AssetResolveBatchResponse messages.

function setAssetResolveBatchCallback

Result< void > setAssetResolveBatchCallback(
    const SessionHandle & handle,
    AssetResolveBatchCallback callback
)

Sets callback for AssetResolveBatch messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetProvideKeyResponseCallback

Result< void > setAssetProvideKeyResponseCallback(
    const SessionHandle & handle,
    AssetProvideKeyResponseCallback callback
)

Sets callback for AssetProvideKeyResponse messages.

function setAssetProvideKeyCallback

Result< void > setAssetProvideKeyCallback(
    const SessionHandle & handle,
    AssetProvideKeyCallback callback
)

Sets callback for AssetProvideKey messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetMetadataResponseCallback

Result< void > setAssetMetadataResponseCallback(
    const SessionHandle & handle,
    NetworkSession::AssetMetadataResponseCallback callback
)

Sets callback for AssetMetadataResponse messages.

function setAssetMetadataCallback

Result< void > setAssetMetadataCallback(
    const SessionHandle & handle,
    NetworkSession::AssetMetadataCallback callback
)

Sets callback for AssetMetadataRequest messages.

function setAssetFetchResponseCallback

Result< void > setAssetFetchResponseCallback(
    const SessionHandle & handle,
    AssetFetchResponseCallback callback
)

Sets callback for AssetFetchResponse messages.

function setAssetFetchCallback

Result< void > setAssetFetchCallback(
    const SessionHandle & handle,
    AssetFetchCallback callback
)

Sets callback for AssetFetch messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAssetAdvertiseResponseCallback

Result< void > setAssetAdvertiseResponseCallback(
    const SessionHandle & handle,
    AssetAdvertiseResponseCallback callback
)

Sets callback for AssetAdvertiseResponse messages.

function setAssetAdvertiseCallback

Result< void > setAssetAdvertiseCallback(
    const SessionHandle & handle,
    AssetAdvertiseCallback callback
)

Sets callback for AssetAdvertise messages.

Parameters:

• handle Session handle
• callback Callback function

Return: Result indicating success or failure

function setAddEntityToSceneResponseCallback

Result< void > setAddEntityToSceneResponseCallback(
    const SessionHandle & handle,
    AddEntityToSceneResponseCallback callback
)

Sets callback for AddEntityToSceneResponse messages.

Parameters:

• handle Session handle
• callback Callback function invoked when AddEntityToSceneResponse is received

Return: Result indicating success or failure

function setAddEntityToSceneCallback

Result< void > setAddEntityToSceneCallback(
    const SessionHandle & handle,
    AddEntityToSceneCallback callback
)

Sets callback for AddEntityToSceneRequest messages.

Parameters:

• handle Session handle
• callback Callback function invoked when AddEntityToSceneRequest is received

Return: Result indicating success or failure

function sendUpdateMaterialPropertyResponse

Result< void > sendUpdateMaterialPropertyResponse(
    const SessionHandle & handle,
    bool success,
    uint64_t newVersion,
    const std::string & errorMessage
)

Sends UpdateMaterialPropertyResponse message.

function sendUpdateMaterialPropertyRequest

Result< void > sendUpdateMaterialPropertyRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    const std::string & propertyName,
    const PropertyValue & value,
    uint64_t requestId =0
)

Sends UpdateMaterialPropertyRequest message.

function sendUpdateMaterialPropertiesBatchResponse

Result< void > sendUpdateMaterialPropertiesBatchResponse(
    const SessionHandle & handle,
    bool success,
    uint64_t newVersion,
    const std::string & errorMessage
)

Sends UpdateMaterialPropertiesBatchResponse message.

function sendUpdateMaterialPropertiesBatchRequest

Result< void > sendUpdateMaterialPropertiesBatchRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    const std::vector< MaterialPropertyData > & properties,
    uint64_t requestId =0
)

Sends UpdateMaterialPropertiesBatchRequest message.

function sendSetSceneEnabledResponse

Result< void > sendSetSceneEnabledResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage
)

Sends SetSceneEnabledResponse message.

function sendSetSceneEnabledRequest

Result< void > sendSetSceneEnabledRequest(
    const SessionHandle & handle,
    uint64_t sceneId,
    bool enabled
)

Sends SetSceneEnabledRequest message.

function sendSceneSnapshot

Result< void > sendSceneSnapshot(
    const SessionHandle & handle,
    const std::vector< uint8_t > & snapshotData
)

Sends SceneSnapshot message (called by handle.sendSceneSnapshot()).

function sendPropertyUpdateBatch

Result< void > sendPropertyUpdateBatch(
    const SessionHandle & handle,
    const std::vector< uint8_t > & batchData
)

Sends PropertyUpdateBatch message (called by handle.sendPropertyUpdateBatch()).

function sendPropertyUpdate

Result< void > sendPropertyUpdate(
    const SessionHandle & handle,
    PropertyHash hash,
    PropertyType type,
    const PropertyValue & value
)

Sends PropertyUpdate message (called by handle.sendPropertyUpdate()).

function sendMeshMaterialBindingUpdate

Result< void > sendMeshMaterialBindingUpdate(
    const SessionHandle & handle,
    uint64_t entityId,
    const std::vector< std::array< uint8_t, 32 > > & materialIds,
    uint64_t originSessionId
)

Sends MeshMaterialBindingUpdate (broadcast).

function sendMeshMaterialBindingResponse

Result< void > sendMeshMaterialBindingResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends MeshMaterialBindingResponse.

function sendMeshMaterialBindingRequest

Result< void > sendMeshMaterialBindingRequest(
    const SessionHandle & handle,
    uint64_t entityId,
    const std::vector< std::array< uint8_t, 32 > > & materialIds,
    uint64_t requestId =0
)

Sends MeshMaterialBindingRequest.

function sendMaterialUnsubscribeResponse

Result< void > sendMaterialUnsubscribeResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage
)

Sends MaterialUnsubscribeResponse message.

function sendMaterialUnsubscribeRequest

Result< void > sendMaterialUnsubscribeRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

Sends MaterialUnsubscribeRequest message.

function sendMaterialSubscribeResponse

Result< void > sendMaterialSubscribeResponse(
    const SessionHandle & handle,
    bool success,
    const MaterialAssetData & material,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends MaterialSubscribeResponse message.

function sendMaterialSubscribeRequest

Result< void > sendMaterialSubscribeRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

Sends MaterialSubscribeRequest message.

function sendMaterialResolved

Result< void > sendMaterialResolved(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    const MaterialAssetData & material
)

Sends MaterialResolved notification.

function sendMaterialPropertyUpdate

Result< void > sendMaterialPropertyUpdate(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    const std::string & propertyName,
    const PropertyValue & value,
    uint64_t newVersion,
    uint64_t originSessionId
)

Sends MaterialPropertyUpdate broadcast message.

function sendHeartbeat

Result< void > sendHeartbeat(
    const SessionHandle & handle
)

Sends Heartbeat message (called by handle.sendHeartbeat()).

function sendGetShaderResponse

Result< void > sendGetShaderResponse(
    const SessionHandle & handle,
    const NetworkSession::GetShaderResponseData & response,
    uint64_t requestId =0
)

Sends GetShaderResponse (server responds with shader data).

function sendGetShaderRequest

Result< void > sendGetShaderRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & shaderAssetId,
    uint64_t requestId =0
)

Sends GetShaderRequest (client requests shader info).

function sendGetMaterialResponse

Result< void > sendGetMaterialResponse(
    const SessionHandle & handle,
    bool success,
    const MaterialAssetData & material,
    const std::string & errorMessage
)

Sends GetMaterialResponse message.

function sendGetMaterialRequest

Result< void > sendGetMaterialRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

Sends GetMaterialRequest message.

function sendEntityDestroyed

Result< void > sendEntityDestroyed(
    const SessionHandle & handle,
    uint64_t entityId
)

Sends EntityDestroyed message (called by handle.sendEntityDestroyed()).

function sendEntityCreated

Result< void > sendEntityCreated(
    const SessionHandle & handle,
    uint64_t entityId,
    const std::string & appId,
    const std::string & typeName,
    uint64_t parentId,
    const std::vector< NetworkSession::ComponentGroupData > & components ={},
    uint64_t targetSceneId =0,
    const std::string & entityName =""
)

Sends EntityCreated message (called by handle.sendEntityCreated()).

function sendDestroySceneResponse

Result< void > sendDestroySceneResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage
)

Sends DestroySceneResponse message.

function sendDestroySceneRequest

Result< void > sendDestroySceneRequest(
    const SessionHandle & handle,
    uint64_t sceneId
)

Sends DestroySceneRequest message.

function sendCreateSceneResponse

Result< void > sendCreateSceneResponse(
    const SessionHandle & handle,
    bool success,
    uint64_t sceneId,
    const std::string & errorMessage
)

Sends CreateSceneResponse message.

function sendCreateSceneRequest

Result< void > sendCreateSceneRequest(
    const SessionHandle & handle,
    const std::string & sceneName,
    bool transient
)

Sends CreateSceneRequest message.

function sendCreateMaterialResponse

Result< void > sendCreateMaterialResponse(
    const SessionHandle & handle,
    bool success,
    const std::array< uint8_t, 32 > & materialId,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends CreateMaterialResponse message.

function sendCreateMaterialRequest

Result< void > sendCreateMaterialRequest(
    const SessionHandle & handle,
    const MaterialAssetData & material,
    uint64_t requestId =0
)

Sends CreateMaterialRequest message.

function sendComponentRemoved

Result< void > sendComponentRemoved(
    const SessionHandle & handle,
    uint64_t entityId,
    ComponentTypeHash typeHash
)

Sends ComponentRemoved message (called by handle.sendComponentRemoved()).

function sendComponentAdded

Result< void > sendComponentAdded(
    const SessionHandle & handle,
    uint64_t entityId,
    const NetworkSession::ComponentGroupData & component
)

Sends ComponentAdded message (called by handle.sendComponentAdded()).

function sendAssetWithdrawAll

Result< void > sendAssetWithdrawAll(
    const SessionHandle & handle,
    const std::string & appId,
    uint64_t requestId =0
)

Sends AssetWithdrawAll request.

function sendAssetWithdraw

Result< void > sendAssetWithdraw(
    const SessionHandle & handle,
    const std::vector< std::array< uint8_t, 32 > > & assetIds,
    uint64_t requestId =0
)

Sends AssetWithdraw request.

function sendAssetUploadResponse

Result< void > sendAssetUploadResponse(
    const SessionHandle & handle,
    bool success,
    const std::array< uint8_t, 32 > & assetId,
    const std::string & uri,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends AssetUploadResponse message.

function sendAssetUploadComplete

Result< void > sendAssetUploadComplete(
    const SessionHandle & handle,
    const NetworkSession::AssetUploadCompleteData & data
)

Completes a chunked upload session.

function sendAssetUploadChunk

Result< void > sendAssetUploadChunk(
    const SessionHandle & handle,
    const NetworkSession::AssetUploadChunkData & data
)

Sends a chunk during chunked upload.

function sendAssetUploadCancel

Result< void > sendAssetUploadCancel(
    const SessionHandle & handle,
    const std::array< uint8_t, 16 > & uploadId
)

Cancels an in-progress chunked upload.

function sendAssetUploadBegin

Result< void > sendAssetUploadBegin(
    const SessionHandle & handle,
    const NetworkSession::AssetUploadBeginData & data
)

Begins a chunked upload session.

function sendAssetUpload

Result< void > sendAssetUpload(
    const SessionHandle & handle,
    const std::string & appId,
    const std::vector< uint8_t > & data,
    uint8_t contentType,
    bool persistent,
    uint64_t requestId =0
)

Sends AssetUpload request.

function sendAssetUpload

Result< void > sendAssetUpload(
    const SessionHandle & handle,
    const std::string & appId,
    const std::vector< uint8_t > & data,
    uint8_t contentType,
    bool persistent,
    uint64_t requestId,
    const NetworkSession::AssetMetadataData & metadata
)

Sends AssetUpload request with metadata.

Parameters:

• metadata Type-specific metadata (shader, texture, etc.)

function sendAssetResolveResponse

Result< void > sendAssetResolveResponse(
    const SessionHandle & handle,
    bool found,
    const AssetEntryData & entry,
    bool hasKey,
    const std::array< uint8_t, 32 > & key,
    uint8_t deliveryMethod,
    uint64_t requestId =0
)

Sends AssetResolveResponse message.

function sendAssetResolveBatch

Result< void > sendAssetResolveBatch(
    const SessionHandle & handle,
    const std::vector< std::array< uint8_t, 32 > > & assetIds,
    uint64_t requestId =0
)

Sends AssetResolveBatch request.

function sendAssetResolve

Result< void > sendAssetResolve(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & assetId,
    uint64_t requestId =0
)

Sends AssetResolve request.

function sendAssetProvideKey

Result< void > sendAssetProvideKey(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & assetId,
    const std::array< uint8_t, 32 > & key,
    uint64_t requestId =0
)

Sends AssetProvideKey request.

function sendAssetMetadataResponse

Result< void > sendAssetMetadataResponse(
    const SessionHandle & handle,
    bool found,
    const NetworkSession::AssetMetadataData & metadata,
    uint64_t requestId =0
)

Sends AssetMetadataResponse message.

function sendAssetMetadataRequest

Result< void > sendAssetMetadataRequest(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & assetId,
    uint64_t requestId =0
)

Sends AssetMetadataRequest message.

function sendAssetFetchResponse

Result< void > sendAssetFetchResponse(
    const SessionHandle & handle,
    bool found,
    const std::vector< uint8_t > & data,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends AssetFetchResponse message.

function sendAssetFetch

Result< void > sendAssetFetch(
    const SessionHandle & handle,
    const std::array< uint8_t, 32 > & assetId,
    uint64_t requestId =0
)

Sends AssetFetch request.

function sendAssetAdvertiseResponse

Result< void > sendAssetAdvertiseResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage,
    uint64_t requestId =0
)

Sends AssetAdvertiseResponse message.

function sendAssetAdvertise

Result< void > sendAssetAdvertise(
    const SessionHandle & handle,
    const std::string & appId,
    const std::vector< NetworkSession::AssetEntryData > & entries,
    uint64_t requestId =0
)

Sends AssetAdvertise request.

function sendAddEntityToSceneResponse

Result< void > sendAddEntityToSceneResponse(
    const SessionHandle & handle,
    bool success,
    const std::string & errorMessage
)

Sends AddEntityToSceneResponse message.

function sendAddEntityToSceneRequest

Result< void > sendAddEntityToSceneRequest(
    const SessionHandle & handle,
    uint64_t entityId,
    uint64_t sceneId
)

Sends AddEntityToSceneRequest message.

function performHandshake

Result< void > performHandshake(
    const SessionHandle & handle,
    const std::string & clientType,
    const std::string & clientId
)

Initiates handshake (called by handle.performHandshake()).

function operator=

SessionManager & operator=(
    const SessionManager &
) =delete

function openChannel

Result< void > openChannel(
    const SessionHandle & handle,
    const std::string & channel
)

Open a named data channel for bulk data transfer.

function isValidHandle

bool isValidHandle(
    const SessionHandle & handle
) const

Validates handle (called by handle.valid()).

function isConnected

bool isConnected(
    const SessionHandle & handle
) const

Checks if connected (called by handle.isConnected()).

function getSchemaRegistry

inline ComponentSchemaRegistry * getSchemaRegistry() const

Get schema registry (if configured).

Return: ComponentSchemaRegistry pointer or nullptr

function getPropertyRegistry

PropertyRegistry & getPropertyRegistry(
    const SessionHandle & handle
)

Gets property registry (called by handle.getPropertyRegistry()).

function getPropertyRegistry

const PropertyRegistry & getPropertyRegistry(
    const SessionHandle & handle
) const

Gets property registry const (called by handle.getPropertyRegistry()).

function getConnectionStats

ConnectionStats getConnectionStats(
    const SessionHandle & handle
) const

Gets connection stats (called by handle.getConnectionStats()).

function getConnectionState

ConnectionState getConnectionState(
    const SessionHandle & handle
) const

Gets connection state (called by handle.getConnectionState()).

function getConnection

ConnectionHandle getConnection(
    const SessionHandle & handle
) const

Gets connection handle (called by handle.getConnection()).

function flushAllPropertyBatches

void flushAllPropertyBatches()

Flush property update batches for all connected sessions.

Iterates through all active sessions and calls flushPropertyUpdates() on each. This is useful for server applications that need to synchronize state updates to hundreds of connected clients efficiently.

Non-blocking: uses try_to_lock to avoid holding up other operations. Continues flushing even if individual sessions fail.

function destroySession

Result< void > destroySession(
    const SessionHandle & handle
)

Destroys a session and returns its slot to the free list.

Parameters:

• handle Session handle to destroy

Return: Result indicating success or failure

This should be called when a session is no longer needed (e.g., after disconnect). After this call, the handle becomes invalid.

function createSession

SessionHandle createSession(
    ConnectionHandle connection,
    PropertyRegistry * externalRegistry =nullptr
)

Creates a new session wrapping the given connection.

Parameters:

• connection Connection handle to wrap
• externalRegistry Optional external PropertyRegistry to share across sessions. If nullptr, each session creates its own internal registry.

Return: SessionHandle for operations, or invalid if full or connection invalid

The session stores a copy of the connection handle and creates a NetworkSession instance internally.

function className

inline virtual const char * className() const override

Runtime class name for diagnostics and reflection.

Reimplements: EntropyEngine::Core::EntropyObject::className

function classHash

virtual uint64_t classHash() const override

Stable type hash for cross-language identification.

Reimplements: EntropyEngine::Core::EntropyObject::classHash

function capacity

inline size_t capacity() const

Gets maximum capacity.

Return: Maximum number of sessions this manager can handle

function broadcastSchemaUnpublish

void broadcastSchemaUnpublish(
    ComponentTypeHash typeHash
)

Broadcast schema unpublish notification to all connected sessions.

Parameters:

• typeHash Component type hash

Called automatically when a schema is unpublished via registry callback. Sends UnpublishSchema message to all sessions with completed handshake.

function broadcastSchemaAdvertisement

void broadcastSchemaAdvertisement(
    ComponentTypeHash typeHash,
    const ComponentSchema & schema
)

Broadcast schema advertisement to all connected sessions.

Parameters:

• typeHash Component type hash
• schema Component schema that was published

Called automatically when a schema is published via registry callback. Sends SchemaAdvertisement message to all sessions with completed handshake.

function broadcastMaterialPropertyUpdate

void broadcastMaterialPropertyUpdate(
    const std::array< uint8_t, 32 > & materialId,
    const std::string & propertyName,
    const PropertyValue & value,
    uint64_t newVersion,
    uint64_t originSessionId,
    const std::vector< uint64_t > & subscribedSessionIds
)

Broadcast material property update to all subscribed sessions except origin.

Parameters:

• materialId The material AssetId that was updated
• propertyName Name of the property that changed
• value New property value
• newVersion New material version after this update
• originSessionId Session that made the change (will be excluded from broadcast)
• subscribedSessionIds List of session IDs subscribed to this material

Used by servers to fan-out material property changes to all clients that have subscribed to the material, excluding the session that originated the change.

function activeCount

inline size_t activeCount() const

Gets active session count.

Return: Number of currently allocated sessions

function SessionManager

explicit SessionManager(
    ConnectionManager * connectionManager,
    size_t capacity,
    ComponentSchemaRegistry * schemaRegistry =nullptr
)

Constructs session manager with specified capacity.

Parameters:

• connectionManager Reference to connection manager (must outlive SessionManager)
• capacity Maximum number of sessions (typically 512-2048)
• schemaRegistry Optional ComponentSchemaRegistry for schema operations (must outlive SessionManager)

function SessionManager

SessionManager(
    const SessionManager &
) =delete

Friends

friend SessionHandle

friend class SessionHandle(
    SessionHandle
);

---

Updated on 2026-01-26 at 16:50:32 -0500