From 0f137a747361f3490a28f542acadc0c8fe53e96b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Luis=20Mill=C3=A1n?= Date: Wed, 13 Sep 2023 13:20:02 +0200 Subject: [PATCH] fbs: FBS WebRtcTransport (#1153) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fbs: FBS WebRtcTransport --------- Co-authored-by: Iñaki Baz Castillo --- node/src/Router.ts | 3 +- node/src/SrtpParameters.ts | 51 +- node/src/Transport.ts | 2 +- node/src/WebRtcTransport.ts | 170 +- node/src/ortc.ts | 11 +- node/src/tests/test-WebRtcTransport.ts | 6 + rust/crypto_suite_fbs.patch | 53 + rust/src/data_structures.rs | 203 +- rust/src/fbs.rs | 35036 ++++++++++--------- rust/src/messages.rs | 226 +- rust/src/router.rs | 15 +- rust/src/router/direct_transport.rs | 6 +- rust/src/router/pipe_transport.rs | 6 +- rust/src/router/plain_transport.rs | 6 +- rust/src/router/webrtc_transport.rs | 194 +- rust/src/srtp_parameters.rs | 56 +- rust/tests/integration/webrtc_transport.rs | 49 +- worker/fbs/pipeTransport.fbs | 7 +- worker/fbs/plainTransport.fbs | 9 +- worker/fbs/request.fbs | 2 +- worker/fbs/srtpParameters.fbs | 15 + worker/fbs/transport.fbs | 17 +- worker/fbs/webRtcTransport.fbs | 57 +- worker/include/RTC/DtlsTransport.hpp | 42 +- worker/include/RTC/IceCandidate.hpp | 6 + worker/include/RTC/IceServer.hpp | 7 +- worker/include/RTC/PlainTransport.hpp | 4 - worker/include/RTC/SrtpSession.hpp | 6 +- worker/src/Channel/ChannelSocket.cpp | 16 +- worker/src/RTC/DtlsTransport.cpp | 173 +- worker/src/RTC/IceCandidate.cpp | 65 +- worker/src/RTC/IceServer.cpp | 37 + worker/src/RTC/PipeTransport.cpp | 11 +- worker/src/RTC/PlainTransport.cpp | 161 +- worker/src/RTC/SrtpSession.cpp | 36 + worker/src/RTC/Transport.cpp | 22 +- worker/src/RTC/WebRtcTransport.cpp | 169 +- 37 files changed, 19479 insertions(+), 17476 deletions(-) create mode 100644 rust/crypto_suite_fbs.patch create mode 100644 worker/fbs/srtpParameters.fbs diff --git a/node/src/Router.ts b/node/src/Router.ts index 2aca8a0c7d..7c3ceff247 100644 --- a/node/src/Router.ts +++ b/node/src/Router.ts @@ -24,6 +24,7 @@ import { AudioLevelObserver, AudioLevelObserverOptions } from './AudioLevelObser import { RtpCapabilities, RtpCodecCapability } from './RtpParameters'; import { NumSctpStreams } from './SctpParameters'; import { AppData, Either } from './types'; +import { cryptoSuiteToFbs } from './SrtpParameters'; import * as FbsActiveSpeakerObserver from './fbs/active-speaker-observer'; import * as FbsAudioLevelObserver from './fbs/audio-level-observer'; import * as FbsRequest from './fbs/request'; @@ -710,7 +711,7 @@ export class Router rtcpMux, comedia, enableSrtp, - srtpCryptoSuite + cryptoSuiteToFbs(srtpCryptoSuite) ); const requestOffset = new FbsRouter.CreatePlainTransportRequestT( diff --git a/node/src/SrtpParameters.ts b/node/src/SrtpParameters.ts index 412c4c6ec9..8049964512 100644 --- a/node/src/SrtpParameters.ts +++ b/node/src/SrtpParameters.ts @@ -1,5 +1,5 @@ import * as flatbuffers from 'flatbuffers'; -import * as FbsTransport from './fbs/transport'; +import * as FbsSrtpParameters from './fbs/srtp-parameters'; /** * SRTP parameters. @@ -26,10 +26,50 @@ export type SrtpCryptoSuite = | 'AES_CM_128_HMAC_SHA1_80' | 'AES_CM_128_HMAC_SHA1_32'; -export function parseSrtpParameters(binary: FbsTransport.SrtpParameters): SrtpParameters +export function cryptoSuiteFromFbs(binary: FbsSrtpParameters.SrtpCryptoSuite): SrtpCryptoSuite +{ + switch (binary) + { + case FbsSrtpParameters.SrtpCryptoSuite.AEAD_AES_256_GCM: + return 'AEAD_AES_256_GCM'; + + case FbsSrtpParameters.SrtpCryptoSuite.AEAD_AES_128_GCM: + return 'AEAD_AES_128_GCM'; + + case FbsSrtpParameters.SrtpCryptoSuite.AES_CM_128_HMAC_SHA1_80: + return 'AES_CM_128_HMAC_SHA1_80'; + + case FbsSrtpParameters.SrtpCryptoSuite.AES_CM_128_HMAC_SHA1_32: + return 'AES_CM_128_HMAC_SHA1_32'; + } +} + +export function cryptoSuiteToFbs(cryptoSuite: SrtpCryptoSuite) + : FbsSrtpParameters.SrtpCryptoSuite +{ + switch (cryptoSuite) + { + case 'AEAD_AES_256_GCM': + return FbsSrtpParameters.SrtpCryptoSuite.AEAD_AES_256_GCM; + + case 'AEAD_AES_128_GCM': + return FbsSrtpParameters.SrtpCryptoSuite.AEAD_AES_128_GCM; + + case 'AES_CM_128_HMAC_SHA1_80': + return FbsSrtpParameters.SrtpCryptoSuite.AES_CM_128_HMAC_SHA1_80; + + case 'AES_CM_128_HMAC_SHA1_32': + return FbsSrtpParameters.SrtpCryptoSuite.AES_CM_128_HMAC_SHA1_32; + + default: + throw new TypeError(`invalid srtp crypto suite: ${cryptoSuite}`); + } +} + +export function parseSrtpParameters(binary: FbsSrtpParameters.SrtpParameters): SrtpParameters { return { - cryptoSuite : binary.cryptoSuite()! as SrtpCryptoSuite, + cryptoSuite : cryptoSuiteFromFbs(binary.cryptoSuite()), keyBase64 : binary.keyBase64()! }; } @@ -38,10 +78,9 @@ export function serializeSrtpParameters( builder:flatbuffers.Builder, srtpParameters:SrtpParameters ): number { - const cryptoSuiteOffset = builder.createString(srtpParameters.cryptoSuite); const keyBase64Offset = builder.createString(srtpParameters.keyBase64); - return FbsTransport.SrtpParameters.createSrtpParameters( - builder, cryptoSuiteOffset, keyBase64Offset + return FbsSrtpParameters.SrtpParameters.createSrtpParameters( + builder, cryptoSuiteToFbs(srtpParameters.cryptoSuite), keyBase64Offset ); } diff --git a/node/src/Transport.ts b/node/src/Transport.ts index 50e53f1594..39e5686d85 100644 --- a/node/src/Transport.ts +++ b/node/src/Transport.ts @@ -1113,7 +1113,7 @@ export class Transport { type = 'sctp'; sctpStreamParameters = - utils.clone(dataProducer.sctpStreamParameters) as SctpStreamParameters; + (utils.clone(dataProducer.sctpStreamParameters) ?? {}) as SctpStreamParameters; // Override if given. if (ordered !== undefined) diff --git a/node/src/WebRtcTransport.ts b/node/src/WebRtcTransport.ts index 3b619c0c3c..719e657026 100644 --- a/node/src/WebRtcTransport.ts +++ b/node/src/WebRtcTransport.ts @@ -28,7 +28,12 @@ import * as FbsRequest from './fbs/request'; import * as FbsTransport from './fbs/transport'; import * as FbsWebRtcTransport from './fbs/web-rtc-transport'; import { DtlsState as FbsDtlsState } from './fbs/web-rtc-transport/dtls-state'; +import { DtlsRole as FbsDtlsRole } from './fbs/web-rtc-transport/dtls-role'; +import { FingerprintAlgorithm as FbsFingerprintAlgorithm } from './fbs/web-rtc-transport/fingerprint-algorithm'; import { IceState as FbsIceState } from './fbs/web-rtc-transport/ice-state'; +import { IceRole as FbsIceRole } from './fbs/web-rtc-transport/ice-role'; +import { IceCandidateType as FbsIceCandidateType } from './fbs/web-rtc-transport/ice-candidate-type'; +import { IceCandidateTcpType as FbsIceCandidateTcpType } from './fbs/web-rtc-transport/ice-candidate-tcp-type'; export type WebRtcTransportOptions = WebRtcTransportOptionsBase & WebRtcTransportListen; @@ -142,8 +147,8 @@ export type IceCandidate = ip: string; protocol: TransportProtocol; port: number; - type: 'host'; - tcpType: 'passive' | undefined; + type: IceCandidateType; + tcpType?: IceCandidateTcpType; }; export type DtlsParameters = @@ -154,18 +159,29 @@ export type DtlsParameters = /** * The hash function algorithm (as defined in the "Hash function Textual Names" - * registry initially specified in RFC 4572 Section 8) and its corresponding - * certificate fingerprint value (in lowercase hex string as expressed utilizing - * the syntax of "fingerprint" in RFC 4572 Section 5). + * registry initially specified in RFC 4572 Section 8). + */ +export type FingerprintAlgorithm = 'sha-1'| 'sha-224'| 'sha-256'| 'sha-384'| 'sha-512'; + +/** + * The hash function algorithm and its corresponding certificate fingerprint + * value (in lowercase hex string as expressed utilizing the syntax of + * "fingerprint" in RFC 4572 Section 5). */ export type DtlsFingerprint = { - algorithm: string; + algorithm: FingerprintAlgorithm; value: string; }; +export type IceRole = 'controlled' | 'controlling'; + export type IceState = 'new' | 'connected' | 'completed' | 'disconnected' | 'closed'; +export type IceCandidateType = 'host'; + +export type IceCandidateTcpType = 'passive'; + export type DtlsRole = 'auto' | 'client' | 'server'; export type DtlsState = 'new' | 'connecting' | 'connected' | 'failed' | 'closed'; @@ -479,7 +495,7 @@ export class WebRtcTransport // Wait for response. const response = await this.channel.request( FbsRequest.Method.WEBRTCTRANSPORT_CONNECT, - FbsRequest.Body.FBS_WebRtcTransport_ConnectRequest, + FbsRequest.Body.WebRtcTransport_ConnectRequest, requestOffset, this.internal.transportId ); @@ -490,8 +506,7 @@ export class WebRtcTransport response.body(data); // Update data. - this.#data.dtlsParameters.role = - data.dtlsLocalRole()! as DtlsRole; + this.#data.dtlsParameters.role = dtlsRoleFromFbs(data.dtlsLocalRole()); } /** @@ -537,7 +552,7 @@ export class WebRtcTransport data!.body(notification); - const iceState = fbsIceState2IceState(notification.iceState()); + const iceState = iceStateFromFbs(notification.iceState()); this.#data.iceState = iceState; @@ -574,7 +589,7 @@ export class WebRtcTransport data!.body(notification); - const dtlsState = fbsDtlsState2DtlsState(notification.dtlsState()); + const dtlsState = dtlsStateFromFbs(notification.dtlsState()); this.#data.dtlsState = dtlsState; @@ -634,7 +649,7 @@ export class WebRtcTransport } } -export function fbsIceState2IceState(fbsIceState: FbsIceState): IceState +function iceStateFromFbs(fbsIceState: FbsIceState): IceState { switch (fbsIceState) { @@ -646,14 +661,39 @@ export function fbsIceState2IceState(fbsIceState: FbsIceState): IceState return 'completed'; case FbsIceState.DISCONNECTED: return 'disconnected'; - case FbsIceState.CLOSED: - return 'closed'; - default: - throw new TypeError(`invalid SctpState: ${fbsIceState}`); } } -export function fbsDtlsState2DtlsState(fbsDtlsState: FbsDtlsState): DtlsState +function iceRoleFromFbs(role: FbsIceRole): IceRole +{ + switch (role) + { + case FbsIceRole.CONTROLLED: + return 'controlled'; + case FbsIceRole.CONTROLLING: + return 'controlling'; + } +} + +function iceCandidateTypeFromFbs(type: FbsIceCandidateType): IceCandidateType +{ + switch (type) + { + case FbsIceCandidateType.HOST: + return 'host'; + } +} + +function iceCandidateTcpTypeFromFbs(type: FbsIceCandidateTcpType): IceCandidateTcpType +{ + switch (type) + { + case FbsIceCandidateTcpType.PASSIVE: + return 'passive'; + } +} + +function dtlsStateFromFbs(fbsDtlsState: FbsDtlsState): DtlsState { switch (fbsDtlsState) { @@ -667,8 +707,72 @@ export function fbsDtlsState2DtlsState(fbsDtlsState: FbsDtlsState): DtlsState return 'failed'; case FbsDtlsState.CLOSED: return 'closed'; + } +} + +function dtlsRoleFromFbs(role: FbsDtlsRole): DtlsRole +{ + switch (role) + { + case FbsDtlsRole.AUTO: + return 'auto'; + case FbsDtlsRole.CLIENT: + return 'client'; + case FbsDtlsRole.SERVER: + return 'server'; + } +} + +function fingerprintAlgorithmsFromFbs(algorithm: FbsFingerprintAlgorithm) + : FingerprintAlgorithm +{ + switch (algorithm) + { + case FbsFingerprintAlgorithm.SHA1: + return 'sha-1'; + case FbsFingerprintAlgorithm.SHA224: + return 'sha-224'; + case FbsFingerprintAlgorithm.SHA256: + return 'sha-256'; + case FbsFingerprintAlgorithm.SHA384: + return 'sha-384'; + case FbsFingerprintAlgorithm.SHA512: + return 'sha-512'; + } +} + +function fingerprintAlgorithmToFbs(algorithm: FingerprintAlgorithm) + : FbsFingerprintAlgorithm +{ + switch (algorithm) + { + case 'sha-1': + return FbsFingerprintAlgorithm.SHA1; + case 'sha-224': + return FbsFingerprintAlgorithm.SHA224; + case 'sha-256': + return FbsFingerprintAlgorithm.SHA256; + case 'sha-384': + return FbsFingerprintAlgorithm.SHA384; + case 'sha-512': + return FbsFingerprintAlgorithm.SHA512; + default: + throw new TypeError(`invalid fingerprint algorithm: ${algorithm}`); + } +} + +function dtlsRoleToFbs(role: DtlsRole): FbsDtlsRole +{ + switch (role) + { + case 'auto': + return FbsDtlsRole.AUTO; + case 'client': + return FbsDtlsRole.CLIENT; + case 'server': + return FbsDtlsRole.SERVER; default: - throw new TypeError(`invalid SctpState: ${fbsDtlsState}`); + throw new TypeError(`invalid dtls role: ${role}`); } } @@ -692,9 +796,9 @@ export function parseWebRtcTransportDumpResponse( iceRole : 'controlled', iceParameters : iceParameters, iceCandidates : iceCandidates, - iceState : binary.iceState() as IceState, + iceState : iceStateFromFbs(binary.iceState()), dtlsParameters : dtlsParameters, - dtlsState : binary.dtlsState() as DtlsState + dtlsState : dtlsStateFromFbs(binary.dtlsState()) }; } @@ -727,12 +831,12 @@ function parseGetStatsResponse( return { ...base, type : 'webrtc-transport', - iceRole : binary.iceRole()!, - iceState : binary.iceState() as IceState, + iceRole : iceRoleFromFbs(binary.iceRole()), + iceState : iceStateFromFbs(binary.iceState()), iceSelectedTuple : binary.iceSelectedTuple() ? parseTuple(binary.iceSelectedTuple()!) : undefined, - dtlsState : binary.dtlsState() as DtlsState + dtlsState : dtlsStateFromFbs(binary.dtlsState()) }; } @@ -744,8 +848,10 @@ function parseIceCandidate(binary: FbsWebRtcTransport.IceCandidate): IceCandidat ip : binary.ip()!, protocol : parseProtocol(binary.protocol()), port : binary.port(), - type : 'host', - tcpType : binary.tcpType() === 'passive' ? 'passive' : undefined + type : iceCandidateTypeFromFbs(binary.type()), + tcpType : binary.tcpType() === null ? + undefined : + iceCandidateTcpTypeFromFbs(binary.tcpType()!) }; } @@ -767,7 +873,7 @@ function parseDtlsParameters(binary: FbsWebRtcTransport.DtlsParameters): DtlsPar const fbsFingerprint = binary.fingerprints(i)!; const fingerPrint : DtlsFingerprint = { - algorithm : fbsFingerprint.algorithm()!, + algorithm : fingerprintAlgorithmsFromFbs(fbsFingerprint.algorithm()), value : fbsFingerprint.value()! }; @@ -776,7 +882,7 @@ function parseDtlsParameters(binary: FbsWebRtcTransport.DtlsParameters): DtlsPar return { fingerprints : fingerprints, - role : binary.role()! as DtlsRole + role : binary.role() === null? undefined : dtlsRoleFromFbs(binary.role()!) }; } @@ -788,20 +894,22 @@ function serializeDtlsParameters( for (const fingerprint of dtlsParameters.fingerprints) { - const algorithmOffset = builder.createString(fingerprint.algorithm); + const algorithm = fingerprintAlgorithmToFbs(fingerprint.algorithm); const valueOffset = builder.createString(fingerprint.value); const fingerprintOffset = FbsWebRtcTransport.Fingerprint.createFingerprint( - builder, algorithmOffset, valueOffset); + builder, algorithm, valueOffset); fingerprints.push(fingerprintOffset); } const fingerprintsOffset = FbsWebRtcTransport.DtlsParameters.createFingerprintsVector( builder, fingerprints); - const roleOffset = builder.createString(dtlsParameters.role); + const role = dtlsParameters.role !== undefined ? + dtlsRoleToFbs(dtlsParameters.role) : + FbsWebRtcTransport.DtlsRole.AUTO; return FbsWebRtcTransport.DtlsParameters.createDtlsParameters( builder, fingerprintsOffset, - roleOffset); + role); } diff --git a/node/src/ortc.ts b/node/src/ortc.ts index b12b8c4e1b..ee0ef59324 100644 --- a/node/src/ortc.ts +++ b/node/src/ortc.ts @@ -1042,7 +1042,8 @@ export function getConsumableRtpParameters( } // Clone Producer encodings since we'll mangle them. - const consumableEncodings = utils.clone(params.encodings) as RtpEncodingParameters[]; + const consumableEncodings = + (utils.clone(params.encodings) ?? []) as RtpEncodingParameters[]; for (let i = 0; i < consumableEncodings.length; ++i) { @@ -1140,7 +1141,7 @@ export function getConsumerRtpParameters( } const consumableCodecs = - utils.clone(consumableRtpParameters.codecs) as RtpCodecParameters[]; + (utils.clone(consumableRtpParameters.codecs) ?? []) as RtpCodecParameters[]; let rtxSupported = false; @@ -1295,7 +1296,7 @@ export function getConsumerRtpParameters( else { const consumableEncodings = - utils.clone(consumableRtpParameters.encodings) as RtpEncodingParameters[]; + (utils.clone(consumableRtpParameters.encodings) ?? []) as RtpEncodingParameters[]; const baseSsrc = utils.generateRandomNumber(); const baseRtxSsrc = utils.generateRandomNumber(); @@ -1347,7 +1348,7 @@ export function getPipeConsumerRtpParameters( }; const consumableCodecs = - utils.clone(consumableRtpParameters.codecs) as RtpCodecParameters[]; + (utils.clone(consumableRtpParameters.codecs) ?? []) as RtpCodecParameters[]; for (const codec of consumableCodecs) { @@ -1375,7 +1376,7 @@ export function getPipeConsumerRtpParameters( )); const consumableEncodings = - utils.clone(consumableRtpParameters.encodings) as RtpEncodingParameters[]; + (utils.clone(consumableRtpParameters.encodings) ?? []) as RtpEncodingParameters[]; const baseSsrc = utils.generateRandomNumber(); const baseRtxSsrc = utils.generateRandomNumber(); diff --git a/node/src/tests/test-WebRtcTransport.ts b/node/src/tests/test-WebRtcTransport.ts index fd4df0dae8..7381610d32 100644 --- a/node/src/tests/test-WebRtcTransport.ts +++ b/node/src/tests/test-WebRtcTransport.ts @@ -292,6 +292,11 @@ test('webRtcTransport.connect() succeeds', async () => expect(transport.dtlsParameters.role).toBe('server'); }, 2000); +/** + * When are we going to rely on the type system in the API? + * We are testing invalid type values which adds extra checks in the code that should be + * simply guarded by the type system. + */ test('webRtcTransport.connect() with wrong arguments rejects with TypeError', async () => { let dtlsRemoteParameters: mediasoup.types.DtlsParameters; @@ -306,6 +311,7 @@ test('webRtcTransport.connect() with wrong arguments rejects with TypeError', as fingerprints : [ { + // @ts-ignore. algorithm : 'sha-256000', value : '82:5A:68:3D:36:C3:0A:DE:AF:E7:32:43:D2:88:83:57:AC:2D:65:E5:80:C4:B6:FB:AF:1A:A0:21:9F:6D:0C:AD' } diff --git a/rust/crypto_suite_fbs.patch b/rust/crypto_suite_fbs.patch new file mode 100644 index 0000000000..0fe4a70870 --- /dev/null +++ b/rust/crypto_suite_fbs.patch @@ -0,0 +1,53 @@ +diff --git a/worker/src/RTC/SrtpSession.cpp b/worker/src/RTC/SrtpSession.cpp +index 97051e0cf..d87f03ae4 100644 +--- a/worker/src/RTC/SrtpSession.cpp ++++ b/worker/src/RTC/SrtpSession.cpp +@@ -1,3 +1,4 @@ ++#include "FBS/srtpParameters_generated.h" + #define MS_CLASS "RTC::SrtpSession" + // #define MS_LOG_DEV_LEVEL 3 + +@@ -28,6 +29,43 @@ namespace RTC + } + } + ++ FBS::SrtpParameters::SrtpCryptoSuite SrtpSession::CryptoSuiteToFbs(CryptoSuite cryptoSuite) ++ { ++ switch (cryptoSuite) ++ { ++ case SrtpSession::CryptoSuite::AEAD_AES_256_GCM: ++ return FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM; ++ ++ case SrtpSession::CryptoSuite::AEAD_AES_128_GCM: ++ return FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_128_GCM; ++ ++ case SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80: ++ return FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_80; ++ ++ case SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32: ++ return FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_32; ++ } ++ } ++ ++ SrtpSession::CryptoSuite SrtpSession::CryptoSuiteFromFbs(FBS::SrtpParameters::SrtpCryptoSuite cryptoSuite) ++ { ++ switch (cryptoSuite) ++ { ++ case FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM: ++ return SrtpSession::CryptoSuite::AEAD_AES_256_GCM; ++ ++ case FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_128_GCM: ++ return SrtpSession::CryptoSuite::AEAD_AES_128_GCM; ++ ++ case FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_80: ++ return SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80; ++ ++ case FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_32: ++ return SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32; ++ } ++ ++ } ++ + void SrtpSession::OnSrtpEvent(srtp_event_data_t* data) + { + MS_TRACE(); diff --git a/rust/src/data_structures.rs b/rust/src/data_structures.rs index eafd39039a..375f233964 100644 --- a/rust/src/data_structures.rs +++ b/rust/src/data_structures.rs @@ -3,7 +3,7 @@ #[cfg(test)] mod tests; -use crate::fbs::{sctp_association, transport}; +use crate::fbs::{sctp_association, transport, web_rtc_transport}; use serde::de::{MapAccess, Visitor}; use serde::ser::SerializeStruct; use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; @@ -96,6 +96,15 @@ pub enum IceRole { Controlling, } +impl IceRole { + pub(crate) fn from_fbs(role: web_rtc_transport::IceRole) -> Self { + match role { + web_rtc_transport::IceRole::Controlled => IceRole::Controlled, + web_rtc_transport::IceRole::Controlling => IceRole::Controlling, + } + } +} + /// ICE parameters. #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] @@ -108,6 +117,16 @@ pub struct IceParameters { pub ice_lite: Option, } +impl IceParameters { + pub(crate) fn from_fbs(parameters: web_rtc_transport::IceParameters) -> Self { + Self { + username_fragment: parameters.username_fragment.to_string(), + password: parameters.password.to_string(), + ice_lite: Some(parameters.ice_lite), + } + } +} + /// ICE candidate type. #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "lowercase")] @@ -128,6 +147,14 @@ pub enum IceCandidateType { Relay, } +impl IceCandidateType { + pub(crate) fn from_fbs(candidate_type: web_rtc_transport::IceCandidateType) -> Self { + match candidate_type { + web_rtc_transport::IceCandidateType::Host => IceCandidateType::Host, + } + } +} + /// ICE candidate TCP type (always `Passive`). #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "lowercase")] @@ -136,6 +163,14 @@ pub enum IceCandidateTcpType { Passive, } +impl IceCandidateTcpType { + pub(crate) fn from_fbs(candidate_type: web_rtc_transport::IceCandidateTcpType) -> Self { + match candidate_type { + web_rtc_transport::IceCandidateTcpType::Passive => IceCandidateTcpType::Passive, + } + } +} + /// Transport protocol. #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "lowercase")] @@ -177,6 +212,20 @@ pub struct IceCandidate { pub tcp_type: Option, } +impl IceCandidate { + pub(crate) fn from_fbs(candidate: &web_rtc_transport::IceCandidate) -> Self { + Self { + foundation: candidate.foundation.clone(), + priority: candidate.priority, + ip: candidate.ip.parse().expect("Error parsing IP address"), + protocol: Protocol::from_fbs(candidate.protocol), + port: candidate.port, + r#type: IceCandidateType::from_fbs(candidate.type_), + tcp_type: candidate.tcp_type.map(IceCandidateTcpType::from_fbs), + } + } +} + /// ICE state. #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] @@ -192,8 +241,17 @@ pub enum IceState { /// ICE was `Connected` or `Completed` but it has suddenly failed (this can just happen if the /// selected tuple has `Tcp` protocol). Disconnected, - /// ICE state when the transport has been closed. - Closed, +} + +impl IceState { + pub(crate) fn from_fbs(state: web_rtc_transport::IceState) -> Self { + match state { + web_rtc_transport::IceState::New => IceState::New, + web_rtc_transport::IceState::Connected => IceState::Connected, + web_rtc_transport::IceState::Completed => IceState::Completed, + web_rtc_transport::IceState::Disconnected => IceState::Disconnected, + } + } } /// Tuple of local IP/port/protocol + optional remote IP/port. @@ -309,6 +367,18 @@ pub enum DtlsState { Closed, } +impl DtlsState { + pub(crate) fn from_fbs(state: web_rtc_transport::DtlsState) -> Self { + match state { + web_rtc_transport::DtlsState::New => DtlsState::New, + web_rtc_transport::DtlsState::Connecting => DtlsState::Connecting, + web_rtc_transport::DtlsState::Connected => DtlsState::Connected, + web_rtc_transport::DtlsState::Failed => DtlsState::Failed, + web_rtc_transport::DtlsState::Closed => DtlsState::Closed, + } + } +} + /// SCTP state. #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] @@ -351,6 +421,24 @@ pub enum DtlsRole { Server, } +impl DtlsRole { + pub(crate) fn to_fbs(self) -> web_rtc_transport::DtlsRole { + match self { + DtlsRole::Auto => web_rtc_transport::DtlsRole::Auto, + DtlsRole::Client => web_rtc_transport::DtlsRole::Client, + DtlsRole::Server => web_rtc_transport::DtlsRole::Server, + } + } + + pub(crate) fn from_fbs(role: web_rtc_transport::DtlsRole) -> Self { + match role { + web_rtc_transport::DtlsRole::Auto => DtlsRole::Auto, + web_rtc_transport::DtlsRole::Client => DtlsRole::Client, + web_rtc_transport::DtlsRole::Server => DtlsRole::Server, + } + } +} + impl Default for DtlsRole { fn default() -> Self { Self::Auto @@ -389,6 +477,91 @@ pub enum DtlsFingerprint { }, } +fn hex_as_bytes(input: &str, output: &mut [u8]) { + for (i, o) in input.split(':').zip(&mut output.iter_mut()) { + *o = u8::from_str_radix(i, 16).unwrap_or_else(|error| { + panic!("Failed to parse value {i} as series of hex bytes: {error}") + }); + } +} + +impl DtlsFingerprint { + pub(crate) fn to_fbs(self) -> web_rtc_transport::Fingerprint { + match self { + DtlsFingerprint::Sha1 { .. } => web_rtc_transport::Fingerprint { + algorithm: web_rtc_transport::FingerprintAlgorithm::Sha1, + value: self.value_string(), + }, + DtlsFingerprint::Sha224 { .. } => web_rtc_transport::Fingerprint { + algorithm: web_rtc_transport::FingerprintAlgorithm::Sha224, + value: self.value_string(), + }, + DtlsFingerprint::Sha256 { .. } => web_rtc_transport::Fingerprint { + algorithm: web_rtc_transport::FingerprintAlgorithm::Sha256, + value: self.value_string(), + }, + DtlsFingerprint::Sha384 { .. } => web_rtc_transport::Fingerprint { + algorithm: web_rtc_transport::FingerprintAlgorithm::Sha384, + value: self.value_string(), + }, + DtlsFingerprint::Sha512 { .. } => web_rtc_transport::Fingerprint { + algorithm: web_rtc_transport::FingerprintAlgorithm::Sha512, + value: self.value_string(), + }, + } + } + + pub(crate) fn from_fbs(fingerprint: &web_rtc_transport::Fingerprint) -> DtlsFingerprint { + match fingerprint.algorithm { + web_rtc_transport::FingerprintAlgorithm::Sha1 => { + let mut value_result = [0_u8; 20]; + + hex_as_bytes(fingerprint.value.as_str(), &mut value_result); + + DtlsFingerprint::Sha1 { + value: value_result, + } + } + web_rtc_transport::FingerprintAlgorithm::Sha224 => { + let mut value_result = [0_u8; 28]; + + hex_as_bytes(fingerprint.value.as_str(), &mut value_result); + + DtlsFingerprint::Sha224 { + value: value_result, + } + } + web_rtc_transport::FingerprintAlgorithm::Sha256 => { + let mut value_result = [0_u8; 32]; + + hex_as_bytes(fingerprint.value.as_str(), &mut value_result); + + DtlsFingerprint::Sha256 { + value: value_result, + } + } + web_rtc_transport::FingerprintAlgorithm::Sha384 => { + let mut value_result = [0_u8; 48]; + + hex_as_bytes(fingerprint.value.as_str(), &mut value_result); + + DtlsFingerprint::Sha384 { + value: value_result, + } + } + web_rtc_transport::FingerprintAlgorithm::Sha512 => { + let mut value_result = [0_u8; 64]; + + hex_as_bytes(fingerprint.value.as_str(), &mut value_result); + + DtlsFingerprint::Sha512 { + value: value_result, + } + } + } + } +} + impl fmt::Debug for DtlsFingerprint { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let name = match self { @@ -826,6 +999,30 @@ pub struct DtlsParameters { pub fingerprints: Vec, } +impl DtlsParameters { + pub(crate) fn to_fbs(&self) -> web_rtc_transport::DtlsParameters { + web_rtc_transport::DtlsParameters { + role: self.role.to_fbs(), + fingerprints: self + .fingerprints + .iter() + .map(|fingerprint| fingerprint.to_fbs()) + .collect(), + } + } + + pub(crate) fn from_fbs(parameters: web_rtc_transport::DtlsParameters) -> DtlsParameters { + DtlsParameters { + role: DtlsRole::from_fbs(parameters.role), + fingerprints: parameters + .fingerprints + .iter() + .map(DtlsFingerprint::from_fbs) + .collect(), + } + } +} + /// Trace event direction #[derive(Debug, Copy, Clone, Deserialize, Serialize)] #[serde(rename_all = "lowercase")] diff --git a/rust/src/fbs.rs b/rust/src/fbs.rs index 11b655b8f8..0089f8c6a6 100644 --- a/rust/src/fbs.rs +++ b/rust/src/fbs.rs @@ -32449,7 +32449,7 @@ mod root { /// The enum `Protocol` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Enum `Protocol` in the file `../worker/fbs/transport.fbs:9` + /// * Enum `Protocol` in the file `../worker/fbs/transport.fbs:10` #[derive( Copy, Clone, @@ -32619,7 +32619,7 @@ mod root { /// The table `ListenInfo` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ListenInfo` in the file `../worker/fbs/transport.fbs:11` + /// * Table `ListenInfo` in the file `../worker/fbs/transport.fbs:12` #[derive( Clone, Debug, @@ -33133,7 +33133,7 @@ mod root { /// The table `RestartIceResponse` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `RestartIceResponse` in the file `../worker/fbs/transport.fbs:20` + /// * Table `RestartIceResponse` in the file `../worker/fbs/transport.fbs:21` #[derive( Clone, Debug, @@ -33482,7 +33482,7 @@ mod root { /// The table `ProduceRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ProduceRequest` in the file `../worker/fbs/transport.fbs:26` + /// * Table `ProduceRequest` in the file `../worker/fbs/transport.fbs:27` #[derive( Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] @@ -33990,7 +33990,7 @@ mod root { /// The table `ProduceResponse` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ProduceResponse` in the file `../worker/fbs/transport.fbs:35` + /// * Table `ProduceResponse` in the file `../worker/fbs/transport.fbs:36` #[derive( Clone, Debug, @@ -34291,7 +34291,7 @@ mod root { /// The table `ConsumeRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ConsumeRequest` in the file `../worker/fbs/transport.fbs:39` + /// * Table `ConsumeRequest` in the file `../worker/fbs/transport.fbs:40` #[derive( Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] @@ -34998,7 +34998,7 @@ mod root { /// The table `ConsumeResponse` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ConsumeResponse` in the file `../worker/fbs/transport.fbs:51` + /// * Table `ConsumeResponse` in the file `../worker/fbs/transport.fbs:52` #[derive( Clone, Debug, @@ -35471,7 +35471,7 @@ mod root { /// The table `ProduceDataRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ProduceDataRequest` in the file `../worker/fbs/transport.fbs:58` + /// * Table `ProduceDataRequest` in the file `../worker/fbs/transport.fbs:59` #[derive( Clone, Debug, @@ -36019,7 +36019,7 @@ mod root { /// The table `ConsumeDataRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `ConsumeDataRequest` in the file `../worker/fbs/transport.fbs:67` + /// * Table `ConsumeDataRequest` in the file `../worker/fbs/transport.fbs:68` #[derive( Clone, Debug, @@ -36665,7 +36665,7 @@ mod root { /// The table `Tuple` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `Tuple` in the file `../worker/fbs/transport.fbs:78` + /// * Table `Tuple` in the file `../worker/fbs/transport.fbs:79` #[derive( Clone, Debug, @@ -37116,301 +37116,10 @@ mod root { } } - /// The table `SrtpParameters` in the namespace `FBS.Transport` - /// - /// Generated from these locations: - /// * Table `SrtpParameters` in the file `../worker/fbs/transport.fbs:86` - #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - pub struct SrtpParameters { - /// The field `crypto_suite` in the table `SrtpParameters` - pub crypto_suite: ::planus::alloc::string::String, - /// The field `key_base64` in the table `SrtpParameters` - pub key_base64: ::planus::alloc::string::String, - } - - impl SrtpParameters { - /// Creates a [SrtpParametersBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> SrtpParametersBuilder<()> { - SrtpParametersBuilder(()) - } - - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_crypto_suite: impl ::planus::WriteAs<::planus::Offset>, - field_key_base64: impl ::planus::WriteAs<::planus::Offset>, - ) -> ::planus::Offset { - let prepared_crypto_suite = field_crypto_suite.prepare(builder); - let prepared_key_base64 = field_key_base64.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<8> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); - - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_crypto_suite); - object_writer.write::<_, _, 4>(&prepared_key_base64); - }); - } - builder.current_offset() - } - } - - impl ::planus::WriteAs<::planus::Offset> for SrtpParameters { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } - - impl ::planus::WriteAsOptional<::planus::Offset> for SrtpParameters { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } - - impl ::planus::WriteAsOffset for SrtpParameters { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - SrtpParameters::create(builder, &self.crypto_suite, &self.key_base64) - } - } - - /// Builder for serializing an instance of the [SrtpParameters] type. - /// - /// Can be created using the [SrtpParameters::builder] method. - #[derive(Debug)] - #[must_use] - pub struct SrtpParametersBuilder(State); - - impl SrtpParametersBuilder<()> { - /// Setter for the [`crypto_suite` field](SrtpParameters#structfield.crypto_suite). - #[inline] - #[allow(clippy::type_complexity)] - pub fn crypto_suite(self, value: T0) -> SrtpParametersBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - SrtpParametersBuilder((value,)) - } - } - - impl SrtpParametersBuilder<(T0,)> { - /// Setter for the [`key_base64` field](SrtpParameters#structfield.key_base64). - #[inline] - #[allow(clippy::type_complexity)] - pub fn key_base64(self, value: T1) -> SrtpParametersBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset>, - { - let (v0,) = self.0; - SrtpParametersBuilder((v0, value)) - } - } - - impl SrtpParametersBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [SrtpParameters]. - #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for SrtpParametersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for SrtpParametersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset for SrtpParametersBuilder<(T0, T1)> - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - SrtpParameters::create(builder, v0, v1) - } - } - - /// Reference to a deserialized [SrtpParameters]. - #[derive(Copy, Clone)] - pub struct SrtpParametersRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> SrtpParametersRef<'a> { - /// Getter for the [`crypto_suite` field](SrtpParameters#structfield.crypto_suite). - #[inline] - pub fn crypto_suite(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "SrtpParameters", "crypto_suite") - } - - /// Getter for the [`key_base64` field](SrtpParameters#structfield.key_base64). - #[inline] - pub fn key_base64(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(1, "SrtpParameters", "key_base64") - } - } - - impl<'a> ::core::fmt::Debug for SrtpParametersRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("SrtpParametersRef"); - f.field("crypto_suite", &self.crypto_suite()); - f.field("key_base64", &self.key_base64()); - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for SrtpParameters { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: SrtpParametersRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - crypto_suite: ::core::convert::TryInto::try_into(value.crypto_suite()?)?, - key_base64: ::core::convert::TryInto::try_into(value.key_base64()?)?, - }) - } - } - - impl<'a> ::planus::TableRead<'a> for SrtpParametersRef<'a> { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) - } - } - - impl<'a> ::planus::VectorReadInner<'a> for SrtpParametersRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[SrtpParametersRef]", - "get", - buffer.offset_from_start, - ) - }) - } - } - - impl ::planus::VectorWrite<::planus::Offset> for SrtpParameters { - type Value = ::planus::Offset; - const STRIDE: usize = 4; - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) - } - - #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); - } - } - } - - impl<'a> ::planus::ReadAsRoot<'a> for SrtpParametersRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[SrtpParametersRef]", "read_as_root", 0) - }) - } - } - /// The table `RtpListener` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `RtpListener` in the file `../worker/fbs/transport.fbs:91` + /// * Table `RtpListener` in the file `../worker/fbs/transport.fbs:87` #[derive( Clone, Debug, @@ -37773,7 +37482,7 @@ mod root { /// The table `SctpListener` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SctpListener` in the file `../worker/fbs/transport.fbs:97` + /// * Table `SctpListener` in the file `../worker/fbs/transport.fbs:93` #[derive( Clone, Debug, @@ -38047,7 +37756,7 @@ mod root { /// The table `RecvRtpHeaderExtensions` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `RecvRtpHeaderExtensions` in the file `../worker/fbs/transport.fbs:101` + /// * Table `RecvRtpHeaderExtensions` in the file `../worker/fbs/transport.fbs:97` #[derive( Clone, Debug, @@ -38570,7 +38279,7 @@ mod root { /// The table `Options` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `Options` in the file `../worker/fbs/transport.fbs:109` + /// * Table `Options` in the file `../worker/fbs/transport.fbs:105` #[derive( Clone, Debug, @@ -38585,10 +38294,10 @@ mod root { pub struct Options { /// The field `direct` in the table `Options` pub direct: bool, - /// The field `max_message_size` in the table `Options` - pub max_message_size: u32, + /// Only needed for DirectTransport. This value is handled by base Transport. + pub max_message_size: ::core::option::Option, /// The field `initial_available_outgoing_bitrate` in the table `Options` - pub initial_available_outgoing_bitrate: u32, + pub initial_available_outgoing_bitrate: ::core::option::Option, /// The field `enable_sctp` in the table `Options` pub enable_sctp: bool, /// The field `num_sctp_streams` in the table `Options` @@ -38608,8 +38317,8 @@ mod root { fn default() -> Self { Self { direct: false, - max_message_size: 0, - initial_available_outgoing_bitrate: 0, + max_message_size: ::core::default::Default::default(), + initial_available_outgoing_bitrate: ::core::default::Default::default(), enable_sctp: false, num_sctp_streams: ::core::default::Default::default(), max_sctp_message_size: 0, @@ -38630,8 +38339,8 @@ mod root { pub fn create( builder: &mut ::planus::Builder, field_direct: impl ::planus::WriteAsDefault, - field_max_message_size: impl ::planus::WriteAsDefault, - field_initial_available_outgoing_bitrate: impl ::planus::WriteAsDefault, + field_max_message_size: impl ::planus::WriteAsOptional, + field_initial_available_outgoing_bitrate: impl ::planus::WriteAsOptional, field_enable_sctp: impl ::planus::WriteAsDefault, field_num_sctp_streams: impl ::planus::WriteAsOptional< ::planus::Offset, @@ -38641,9 +38350,9 @@ mod root { field_is_data_channel: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { let prepared_direct = field_direct.prepare(builder, &false); - let prepared_max_message_size = field_max_message_size.prepare(builder, &0); + let prepared_max_message_size = field_max_message_size.prepare(builder); let prepared_initial_available_outgoing_bitrate = - field_initial_available_outgoing_bitrate.prepare(builder, &0); + field_initial_available_outgoing_bitrate.prepare(builder); let prepared_enable_sctp = field_enable_sctp.prepare(builder, &false); let prepared_num_sctp_streams = field_num_sctp_streams.prepare(builder); let prepared_max_sctp_message_size = @@ -38797,19 +38506,17 @@ mod root { #[allow(clippy::type_complexity)] pub fn max_message_size(self, value: T1) -> OptionsBuilder<(T0, T1)> where - T1: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional, { let (v0,) = self.0; OptionsBuilder((v0, value)) } - /// Sets the [`max_message_size` field](Options#structfield.max_message_size) to the default value. + /// Sets the [`max_message_size` field](Options#structfield.max_message_size) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn max_message_size_as_default( - self, - ) -> OptionsBuilder<(T0, ::planus::DefaultValue)> { - self.max_message_size(::planus::DefaultValue) + pub fn max_message_size_as_null(self) -> OptionsBuilder<(T0, ())> { + self.max_message_size(()) } } @@ -38822,19 +38529,19 @@ mod root { value: T2, ) -> OptionsBuilder<(T0, T1, T2)> where - T2: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptional, { let (v0, v1) = self.0; OptionsBuilder((v0, v1, value)) } - /// Sets the [`initial_available_outgoing_bitrate` field](Options#structfield.initial_available_outgoing_bitrate) to the default value. + /// Sets the [`initial_available_outgoing_bitrate` field](Options#structfield.initial_available_outgoing_bitrate) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn initial_available_outgoing_bitrate_as_default( + pub fn initial_available_outgoing_bitrate_as_null( self, - ) -> OptionsBuilder<(T0, T1, ::planus::DefaultValue)> { - self.initial_available_outgoing_bitrate(::planus::DefaultValue) + ) -> OptionsBuilder<(T0, T1, ())> { + self.initial_available_outgoing_bitrate(()) } } @@ -38972,8 +38679,8 @@ mod root { impl< T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional, T3: ::planus::WriteAsDefault, T4: ::planus::WriteAsOptional< ::planus::Offset, @@ -38994,8 +38701,8 @@ mod root { impl< T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional, T3: ::planus::WriteAsDefault, T4: ::planus::WriteAsOptional< ::planus::Offset, @@ -39019,8 +38726,8 @@ mod root { impl< T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional, T3: ::planus::WriteAsDefault, T4: ::planus::WriteAsOptional< ::planus::Offset, @@ -39053,22 +38760,17 @@ mod root { /// Getter for the [`max_message_size` field](Options#structfield.max_message_size). #[inline] - pub fn max_message_size(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "Options", "max_message_size")? - .unwrap_or(0), - ) + pub fn max_message_size(&self) -> ::planus::Result<::core::option::Option> { + self.0.access(1, "Options", "max_message_size") } /// Getter for the [`initial_available_outgoing_bitrate` field](Options#structfield.initial_available_outgoing_bitrate). #[inline] - pub fn initial_available_outgoing_bitrate(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "Options", "initial_available_outgoing_bitrate")? - .unwrap_or(0), - ) + pub fn initial_available_outgoing_bitrate( + &self, + ) -> ::planus::Result<::core::option::Option> { + self.0 + .access(2, "Options", "initial_available_outgoing_bitrate") } /// Getter for the [`enable_sctp` field](Options#structfield.enable_sctp). @@ -39124,11 +38826,19 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("OptionsRef"); f.field("direct", &self.direct()); - f.field("max_message_size", &self.max_message_size()); - f.field( - "initial_available_outgoing_bitrate", - &self.initial_available_outgoing_bitrate(), - ); + if let ::core::option::Option::Some(field_max_message_size) = + self.max_message_size().transpose() + { + f.field("max_message_size", &field_max_message_size); + } + if let ::core::option::Option::Some(field_initial_available_outgoing_bitrate) = + self.initial_available_outgoing_bitrate().transpose() + { + f.field( + "initial_available_outgoing_bitrate", + &field_initial_available_outgoing_bitrate, + ); + } f.field("enable_sctp", &self.enable_sctp()); if let ::core::option::Option::Some(field_num_sctp_streams) = self.num_sctp_streams().transpose() @@ -39149,12 +38859,26 @@ mod root { fn try_from(value: OptionsRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { direct: ::core::convert::TryInto::try_into(value.direct()?)?, - max_message_size: ::core::convert::TryInto::try_into( - value.max_message_size()?, - )?, - initial_available_outgoing_bitrate: ::core::convert::TryInto::try_into( - value.initial_available_outgoing_bitrate()?, - )?, + max_message_size: if let ::core::option::Option::Some(max_message_size) = + value.max_message_size()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + max_message_size, + )?) + } else { + ::core::option::Option::None + }, + initial_available_outgoing_bitrate: if let ::core::option::Option::Some( + initial_available_outgoing_bitrate, + ) = + value.initial_available_outgoing_bitrate()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + initial_available_outgoing_bitrate, + )?) + } else { + ::core::option::Option::None + }, enable_sctp: ::core::convert::TryInto::try_into(value.enable_sctp()?)?, num_sctp_streams: if let ::core::option::Option::Some(num_sctp_streams) = value.num_sctp_streams()? @@ -39251,7 +38975,7 @@ mod root { /// The table `Dump` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `Dump` in the file `../worker/fbs/transport.fbs:120` + /// * Table `Dump` in the file `../worker/fbs/transport.fbs:117` #[derive( Clone, Debug, @@ -40288,7 +40012,7 @@ mod root { /// The table `Stats` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `Stats` in the file `../worker/fbs/transport.fbs:138` + /// * Table `Stats` in the file `../worker/fbs/transport.fbs:135` #[derive( Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] @@ -40332,11 +40056,11 @@ mod root { /// The field `available_incoming_bitrate` in the table `Stats` pub available_incoming_bitrate: ::core::option::Option, /// The field `max_incoming_bitrate` in the table `Stats` - pub max_incoming_bitrate: u32, + pub max_incoming_bitrate: ::core::option::Option, /// The field `max_outgoing_bitrate` in the table `Stats` - pub max_outgoing_bitrate: u32, + pub max_outgoing_bitrate: ::core::option::Option, /// The field `min_outgoing_bitrate` in the table `Stats` - pub min_outgoing_bitrate: u32, + pub min_outgoing_bitrate: ::core::option::Option, /// The field `rtp_packet_loss_received` in the table `Stats` pub rtp_packet_loss_received: ::core::option::Option, /// The field `rtp_packet_loss_sent` in the table `Stats` @@ -40372,9 +40096,9 @@ mod root { field_probation_send_bitrate: impl ::planus::WriteAsDefault, field_available_outgoing_bitrate: impl ::planus::WriteAsOptional, field_available_incoming_bitrate: impl ::planus::WriteAsOptional, - field_max_incoming_bitrate: impl ::planus::WriteAsDefault, - field_max_outgoing_bitrate: impl ::planus::WriteAsDefault, - field_min_outgoing_bitrate: impl ::planus::WriteAsDefault, + field_max_incoming_bitrate: impl ::planus::WriteAsOptional, + field_max_outgoing_bitrate: impl ::planus::WriteAsOptional, + field_min_outgoing_bitrate: impl ::planus::WriteAsOptional, field_rtp_packet_loss_received: impl ::planus::WriteAsOptional, field_rtp_packet_loss_sent: impl ::planus::WriteAsOptional, ) -> ::planus::Offset { @@ -40401,12 +40125,9 @@ mod root { field_available_outgoing_bitrate.prepare(builder); let prepared_available_incoming_bitrate = field_available_incoming_bitrate.prepare(builder); - let prepared_max_incoming_bitrate = - field_max_incoming_bitrate.prepare(builder, &0); - let prepared_max_outgoing_bitrate = - field_max_outgoing_bitrate.prepare(builder, &0); - let prepared_min_outgoing_bitrate = - field_min_outgoing_bitrate.prepare(builder, &0); + let prepared_max_incoming_bitrate = field_max_incoming_bitrate.prepare(builder); + let prepared_max_outgoing_bitrate = field_max_outgoing_bitrate.prepare(builder); + let prepared_min_outgoing_bitrate = field_min_outgoing_bitrate.prepare(builder); let prepared_rtp_packet_loss_received = field_rtp_packet_loss_received.prepare(builder); let prepared_rtp_packet_loss_sent = field_rtp_packet_loss_sent.prepare(builder); @@ -41566,7 +41287,7 @@ mod root { T19, )> where - T19: ::planus::WriteAsDefault, + T19: ::planus::WriteAsOptional, { let ( v0, @@ -41595,10 +41316,10 @@ mod root { )) } - /// Sets the [`max_incoming_bitrate` field](Stats#structfield.max_incoming_bitrate) to the default value. + /// Sets the [`max_incoming_bitrate` field](Stats#structfield.max_incoming_bitrate) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn max_incoming_bitrate_as_default( + pub fn max_incoming_bitrate_as_null( self, ) -> StatsBuilder<( T0, @@ -41620,9 +41341,9 @@ mod root { T16, T17, T18, - ::planus::DefaultValue, + (), )> { - self.max_incoming_bitrate(::planus::DefaultValue) + self.max_incoming_bitrate(()) } } @@ -41701,7 +41422,7 @@ mod root { T20, )> where - T20: ::planus::WriteAsDefault, + T20: ::planus::WriteAsOptional, { let ( v0, @@ -41731,10 +41452,10 @@ mod root { )) } - /// Sets the [`max_outgoing_bitrate` field](Stats#structfield.max_outgoing_bitrate) to the default value. + /// Sets the [`max_outgoing_bitrate` field](Stats#structfield.max_outgoing_bitrate) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn max_outgoing_bitrate_as_default( + pub fn max_outgoing_bitrate_as_null( self, ) -> StatsBuilder<( T0, @@ -41757,298 +41478,298 @@ mod root { T17, T18, T19, - ::planus::DefaultValue, - )> { - self.max_outgoing_bitrate(::planus::DefaultValue) - } - } - - impl< - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - > - StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - )> - { - /// Setter for the [`min_outgoing_bitrate` field](Stats#structfield.min_outgoing_bitrate). - #[inline] - #[allow(clippy::type_complexity)] - pub fn min_outgoing_bitrate( - self, - value: T21, - ) -> StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - T21, - )> - where - T21: ::planus::WriteAsDefault, - { - let ( - v0, - v1, - v2, - v3, - v4, - v5, - v6, - v7, - v8, - v9, - v10, - v11, - v12, - v13, - v14, - v15, - v16, - v17, - v18, - v19, - v20, - ) = self.0; - StatsBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, - v17, v18, v19, v20, value, - )) - } - - /// Sets the [`min_outgoing_bitrate` field](Stats#structfield.min_outgoing_bitrate) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn min_outgoing_bitrate_as_default( - self, - ) -> StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - ::planus::DefaultValue, - )> { - self.min_outgoing_bitrate(::planus::DefaultValue) - } - } - - impl< - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - T21, - > - StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - T21, - )> - { - /// Setter for the [`rtp_packet_loss_received` field](Stats#structfield.rtp_packet_loss_received). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtp_packet_loss_received( - self, - value: T22, - ) -> StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - T21, - T22, - )> - where - T22: ::planus::WriteAsOptional, - { - let ( - v0, - v1, - v2, - v3, - v4, - v5, - v6, - v7, - v8, - v9, - v10, - v11, - v12, - v13, - v14, - v15, - v16, - v17, - v18, - v19, - v20, - v21, - ) = self.0; - StatsBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, - v17, v18, v19, v20, v21, value, - )) - } - - /// Sets the [`rtp_packet_loss_received` field](Stats#structfield.rtp_packet_loss_received) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtp_packet_loss_received_as_null( - self, - ) -> StatsBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16, - T17, - T18, - T19, - T20, - T21, (), )> { - self.rtp_packet_loss_received(()) + self.max_outgoing_bitrate(()) + } + } + + impl< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + > + StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + )> + { + /// Setter for the [`min_outgoing_bitrate` field](Stats#structfield.min_outgoing_bitrate). + #[inline] + #[allow(clippy::type_complexity)] + pub fn min_outgoing_bitrate( + self, + value: T21, + ) -> StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + )> + where + T21: ::planus::WriteAsOptional, + { + let ( + v0, + v1, + v2, + v3, + v4, + v5, + v6, + v7, + v8, + v9, + v10, + v11, + v12, + v13, + v14, + v15, + v16, + v17, + v18, + v19, + v20, + ) = self.0; + StatsBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, + v17, v18, v19, v20, value, + )) + } + + /// Sets the [`min_outgoing_bitrate` field](Stats#structfield.min_outgoing_bitrate) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn min_outgoing_bitrate_as_null( + self, + ) -> StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + (), + )> { + self.min_outgoing_bitrate(()) + } + } + + impl< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + > + StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + )> + { + /// Setter for the [`rtp_packet_loss_received` field](Stats#structfield.rtp_packet_loss_received). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_packet_loss_received( + self, + value: T22, + ) -> StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + )> + where + T22: ::planus::WriteAsOptional, + { + let ( + v0, + v1, + v2, + v3, + v4, + v5, + v6, + v7, + v8, + v9, + v10, + v11, + v12, + v13, + v14, + v15, + v16, + v17, + v18, + v19, + v20, + v21, + ) = self.0; + StatsBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, + v17, v18, v19, v20, v21, value, + )) + } + + /// Sets the [`rtp_packet_loss_received` field](Stats#structfield.rtp_packet_loss_received) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_packet_loss_received_as_null( + self, + ) -> StatsBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + (), + )> { + self.rtp_packet_loss_received(()) } } @@ -42287,9 +42008,9 @@ mod root { T16: ::planus::WriteAsDefault, T17: ::planus::WriteAsOptional, T18: ::planus::WriteAsOptional, - T19: ::planus::WriteAsDefault, - T20: ::planus::WriteAsDefault, - T21: ::planus::WriteAsDefault, + T19: ::planus::WriteAsOptional, + T20: ::planus::WriteAsOptional, + T21: ::planus::WriteAsOptional, T22: ::planus::WriteAsOptional, T23: ::planus::WriteAsOptional, > ::planus::WriteAs<::planus::Offset> @@ -42348,9 +42069,9 @@ mod root { T16: ::planus::WriteAsDefault, T17: ::planus::WriteAsOptional, T18: ::planus::WriteAsOptional, - T19: ::planus::WriteAsDefault, - T20: ::planus::WriteAsDefault, - T21: ::planus::WriteAsDefault, + T19: ::planus::WriteAsOptional, + T20: ::planus::WriteAsOptional, + T21: ::planus::WriteAsOptional, T22: ::planus::WriteAsOptional, T23: ::planus::WriteAsOptional, > ::planus::WriteAsOptional<::planus::Offset> @@ -42412,9 +42133,9 @@ mod root { T16: ::planus::WriteAsDefault, T17: ::planus::WriteAsOptional, T18: ::planus::WriteAsOptional, - T19: ::planus::WriteAsDefault, - T20: ::planus::WriteAsDefault, - T21: ::planus::WriteAsDefault, + T19: ::planus::WriteAsOptional, + T20: ::planus::WriteAsOptional, + T21: ::planus::WriteAsOptional, T22: ::planus::WriteAsOptional, T23: ::planus::WriteAsOptional, > ::planus::WriteAsOffset @@ -42644,32 +42365,26 @@ mod root { /// Getter for the [`max_incoming_bitrate` field](Stats#structfield.max_incoming_bitrate). #[inline] - pub fn max_incoming_bitrate(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(19, "Stats", "max_incoming_bitrate")? - .unwrap_or(0), - ) + pub fn max_incoming_bitrate( + &self, + ) -> ::planus::Result<::core::option::Option> { + self.0.access(19, "Stats", "max_incoming_bitrate") } /// Getter for the [`max_outgoing_bitrate` field](Stats#structfield.max_outgoing_bitrate). #[inline] - pub fn max_outgoing_bitrate(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(20, "Stats", "max_outgoing_bitrate")? - .unwrap_or(0), - ) + pub fn max_outgoing_bitrate( + &self, + ) -> ::planus::Result<::core::option::Option> { + self.0.access(20, "Stats", "max_outgoing_bitrate") } /// Getter for the [`min_outgoing_bitrate` field](Stats#structfield.min_outgoing_bitrate). #[inline] - pub fn min_outgoing_bitrate(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(21, "Stats", "min_outgoing_bitrate")? - .unwrap_or(0), - ) + pub fn min_outgoing_bitrate( + &self, + ) -> ::planus::Result<::core::option::Option> { + self.0.access(21, "Stats", "min_outgoing_bitrate") } /// Getter for the [`rtp_packet_loss_received` field](Stats#structfield.rtp_packet_loss_received). @@ -42729,9 +42444,21 @@ mod root { &field_available_incoming_bitrate, ); } - f.field("max_incoming_bitrate", &self.max_incoming_bitrate()); - f.field("max_outgoing_bitrate", &self.max_outgoing_bitrate()); - f.field("min_outgoing_bitrate", &self.min_outgoing_bitrate()); + if let ::core::option::Option::Some(field_max_incoming_bitrate) = + self.max_incoming_bitrate().transpose() + { + f.field("max_incoming_bitrate", &field_max_incoming_bitrate); + } + if let ::core::option::Option::Some(field_max_outgoing_bitrate) = + self.max_outgoing_bitrate().transpose() + { + f.field("max_outgoing_bitrate", &field_max_outgoing_bitrate); + } + if let ::core::option::Option::Some(field_min_outgoing_bitrate) = + self.min_outgoing_bitrate().transpose() + { + f.field("min_outgoing_bitrate", &field_min_outgoing_bitrate); + } if let ::core::option::Option::Some(field_rtp_packet_loss_received) = self.rtp_packet_loss_received().transpose() { @@ -42819,15 +42546,36 @@ mod root { } else { ::core::option::Option::None }, - max_incoming_bitrate: ::core::convert::TryInto::try_into( - value.max_incoming_bitrate()?, - )?, - max_outgoing_bitrate: ::core::convert::TryInto::try_into( - value.max_outgoing_bitrate()?, - )?, - min_outgoing_bitrate: ::core::convert::TryInto::try_into( - value.min_outgoing_bitrate()?, - )?, + max_incoming_bitrate: if let ::core::option::Option::Some( + max_incoming_bitrate, + ) = value.max_incoming_bitrate()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + max_incoming_bitrate, + )?) + } else { + ::core::option::Option::None + }, + max_outgoing_bitrate: if let ::core::option::Option::Some( + max_outgoing_bitrate, + ) = value.max_outgoing_bitrate()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + max_outgoing_bitrate, + )?) + } else { + ::core::option::Option::None + }, + min_outgoing_bitrate: if let ::core::option::Option::Some( + min_outgoing_bitrate, + ) = value.min_outgoing_bitrate()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + min_outgoing_bitrate, + )?) + } else { + ::core::option::Option::None + }, rtp_packet_loss_received: if let ::core::option::Option::Some( rtp_packet_loss_received, ) = value.rtp_packet_loss_received()? @@ -42925,7 +42673,7 @@ mod root { /// The table `SetMaxIncomingBitrateRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SetMaxIncomingBitrateRequest` in the file `../worker/fbs/transport.fbs:165` + /// * Table `SetMaxIncomingBitrateRequest` in the file `../worker/fbs/transport.fbs:162` #[derive( Clone, Debug, @@ -43233,7 +42981,7 @@ mod root { /// The table `SetMaxOutgoingBitrateRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SetMaxOutgoingBitrateRequest` in the file `../worker/fbs/transport.fbs:169` + /// * Table `SetMaxOutgoingBitrateRequest` in the file `../worker/fbs/transport.fbs:166` #[derive( Clone, Debug, @@ -43541,7 +43289,7 @@ mod root { /// The table `SetMinOutgoingBitrateRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SetMinOutgoingBitrateRequest` in the file `../worker/fbs/transport.fbs:173` + /// * Table `SetMinOutgoingBitrateRequest` in the file `../worker/fbs/transport.fbs:170` #[derive( Clone, Debug, @@ -43849,7 +43597,7 @@ mod root { /// The table `EnableTraceEventRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `EnableTraceEventRequest` in the file `../worker/fbs/transport.fbs:177` + /// * Table `EnableTraceEventRequest` in the file `../worker/fbs/transport.fbs:174` #[derive( Clone, Debug, @@ -44121,7 +43869,7 @@ mod root { /// The table `CloseProducerRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `CloseProducerRequest` in the file `../worker/fbs/transport.fbs:181` + /// * Table `CloseProducerRequest` in the file `../worker/fbs/transport.fbs:178` #[derive( Clone, Debug, @@ -44387,7 +44135,7 @@ mod root { /// The table `CloseConsumerRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `CloseConsumerRequest` in the file `../worker/fbs/transport.fbs:185` + /// * Table `CloseConsumerRequest` in the file `../worker/fbs/transport.fbs:182` #[derive( Clone, Debug, @@ -44653,7 +44401,7 @@ mod root { /// The table `CloseDataProducerRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `CloseDataProducerRequest` in the file `../worker/fbs/transport.fbs:189` + /// * Table `CloseDataProducerRequest` in the file `../worker/fbs/transport.fbs:186` #[derive( Clone, Debug, @@ -44928,7 +44676,7 @@ mod root { /// The table `CloseDataConsumerRequest` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `CloseDataConsumerRequest` in the file `../worker/fbs/transport.fbs:193` + /// * Table `CloseDataConsumerRequest` in the file `../worker/fbs/transport.fbs:190` #[derive( Clone, Debug, @@ -45203,7 +44951,7 @@ mod root { /// The table `SendRtcpNotification` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SendRtcpNotification` in the file `../worker/fbs/transport.fbs:199` + /// * Table `SendRtcpNotification` in the file `../worker/fbs/transport.fbs:196` #[derive( Clone, Debug, @@ -45468,7 +45216,7 @@ mod root { /// The table `SctpStateChangeNotification` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `SctpStateChangeNotification` in the file `../worker/fbs/transport.fbs:205` + /// * Table `SctpStateChangeNotification` in the file `../worker/fbs/transport.fbs:202` #[derive( Clone, Debug, @@ -45789,7 +45537,7 @@ mod root { /// The enum `TraceType` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Enum `TraceType` in the file `../worker/fbs/transport.fbs:209` + /// * Enum `TraceType` in the file `../worker/fbs/transport.fbs:206` #[derive( Copy, Clone, @@ -45959,7 +45707,7 @@ mod root { /// The enum `TraceDirection` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Enum `TraceDirection` in the file `../worker/fbs/transport.fbs:211` + /// * Enum `TraceDirection` in the file `../worker/fbs/transport.fbs:208` #[derive( Copy, Clone, @@ -46129,7 +45877,7 @@ mod root { /// The union `TraceInfo` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Union `TraceInfo` in the file `../worker/fbs/transport.fbs:213` + /// * Union `TraceInfo` in the file `../worker/fbs/transport.fbs:210` #[derive( Clone, Debug, @@ -46282,7 +46030,7 @@ mod root { /// The enum `BweType` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Enum `BweType` in the file `../worker/fbs/transport.fbs:217` + /// * Enum `BweType` in the file `../worker/fbs/transport.fbs:214` #[derive( Copy, Clone, @@ -46452,7 +46200,7 @@ mod root { /// The table `BweTraceInfo` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `BweTraceInfo` in the file `../worker/fbs/transport.fbs:219` + /// * Table `BweTraceInfo` in the file `../worker/fbs/transport.fbs:216` #[derive( Clone, Debug, @@ -47135,7 +46883,7 @@ mod root { /// The table `TraceNotification` in the namespace `FBS.Transport` /// /// Generated from these locations: - /// * Table `TraceNotification` in the file `../worker/fbs/transport.fbs:230` + /// * Table `TraceNotification` in the file `../worker/fbs/transport.fbs:227` #[derive( Clone, Debug, @@ -47780,257 +47528,15 @@ mod root { } } } - /// The namespace `FBS.Log` + /// The namespace `FBS.SrtpParameters` /// /// Generated from these locations: - /// * File `../worker/fbs/log.fbs` - pub mod log { - /// The table `Log` in the namespace `FBS.Log` + /// * File `../worker/fbs/srtpParameters.fbs` + pub mod srtp_parameters { + /// The enum `SrtpCryptoSuite` in the namespace `FBS.SrtpParameters` /// /// Generated from these locations: - /// * Table `Log` in the file `../worker/fbs/log.fbs:4` - #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - pub struct Log { - /// The field `data` in the table `Log` - pub data: ::planus::alloc::string::String, - } - - impl Log { - /// Creates a [LogBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> LogBuilder<()> { - LogBuilder(()) - } - - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_data: impl ::planus::WriteAs<::planus::Offset>, - ) -> ::planus::Offset { - let prepared_data = field_data.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_data); - }); - } - builder.current_offset() - } - } - - impl ::planus::WriteAs<::planus::Offset> for Log { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } - - impl ::planus::WriteAsOptional<::planus::Offset> for Log { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } - - impl ::planus::WriteAsOffset for Log { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - Log::create(builder, &self.data) - } - } - - /// Builder for serializing an instance of the [Log] type. - /// - /// Can be created using the [Log::builder] method. - #[derive(Debug)] - #[must_use] - pub struct LogBuilder(State); - - impl LogBuilder<()> { - /// Setter for the [`data` field](Log#structfield.data). - #[inline] - #[allow(clippy::type_complexity)] - pub fn data(self, value: T0) -> LogBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - LogBuilder((value,)) - } - } - - impl LogBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Log]. - #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) - } - } - - impl>> - ::planus::WriteAs<::planus::Offset> for LogBuilder<(T0,)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } - - impl>> - ::planus::WriteAsOptional<::planus::Offset> for LogBuilder<(T0,)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } - - impl>> ::planus::WriteAsOffset - for LogBuilder<(T0,)> - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0,) = &self.0; - Log::create(builder, v0) - } - } - - /// Reference to a deserialized [Log]. - #[derive(Copy, Clone)] - pub struct LogRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> LogRef<'a> { - /// Getter for the [`data` field](Log#structfield.data). - #[inline] - pub fn data(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "Log", "data") - } - } - - impl<'a> ::core::fmt::Debug for LogRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("LogRef"); - f.field("data", &self.data()); - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for Log { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: LogRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - data: ::core::convert::TryInto::try_into(value.data()?)?, - }) - } - } - - impl<'a> ::planus::TableRead<'a> for LogRef<'a> { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) - } - } - - impl<'a> ::planus::VectorReadInner<'a> for LogRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location("[LogRef]", "get", buffer.offset_from_start) - }) - } - } - - impl ::planus::VectorWrite<::planus::Offset> for Log { - type Value = ::planus::Offset; - const STRIDE: usize = 4; - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) - } - - #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); - } - } - } - - impl<'a> ::planus::ReadAsRoot<'a> for LogRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[LogRef]", "read_as_root", 0) - }) - } - } - } - /// The namespace `FBS.Message` - /// - /// Generated from these locations: - /// * File `../worker/fbs/message.fbs` - pub mod message { - /// The enum `Type` in the namespace `FBS.Message` - /// - /// Generated from these locations: - /// * Enum `Type` in the file `../worker/fbs/message.fbs:8` + /// * Enum `SrtpCryptoSuite` in the file `../worker/fbs/srtpParameters.fbs:4` #[derive( Copy, Clone, @@ -48044,27 +47550,31 @@ mod root { ::serde::Deserialize, )] #[repr(u8)] - pub enum Type { - /// The variant `REQUEST` in the enum `Type` - Request = 0, + pub enum SrtpCryptoSuite { + /// The variant `AEAD_AES_256_GCM` in the enum `SrtpCryptoSuite` + AeadAes256Gcm = 0, - /// The variant `RESPONSE` in the enum `Type` - Response = 1, + /// The variant `AEAD_AES_128_GCM` in the enum `SrtpCryptoSuite` + AeadAes128Gcm = 1, - /// The variant `NOTIFICATION` in the enum `Type` - Notification = 2, + /// The variant `AES_CM_128_HMAC_SHA1_80` in the enum `SrtpCryptoSuite` + AesCm128HmacSha180 = 2, - /// The variant `LOG` in the enum `Type` - Log = 3, + /// The variant `AES_CM_128_HMAC_SHA1_32` in the enum `SrtpCryptoSuite` + AesCm128HmacSha132 = 3, } - impl Type { - /// Array containing all valid variants of Type - pub const ENUM_VALUES: [Self; 4] = - [Self::Request, Self::Response, Self::Notification, Self::Log]; + impl SrtpCryptoSuite { + /// Array containing all valid variants of SrtpCryptoSuite + pub const ENUM_VALUES: [Self; 4] = [ + Self::AeadAes256Gcm, + Self::AeadAes128Gcm, + Self::AesCm128HmacSha180, + Self::AesCm128HmacSha132, + ]; } - impl ::core::convert::TryFrom for Type { + impl ::core::convert::TryFrom for SrtpCryptoSuite { type Error = ::planus::errors::UnknownEnumTagKind; #[inline] fn try_from( @@ -48073,10 +47583,10 @@ mod root { { #[allow(clippy::match_single_binding)] match value { - 0 => ::core::result::Result::Ok(Type::Request), - 1 => ::core::result::Result::Ok(Type::Response), - 2 => ::core::result::Result::Ok(Type::Notification), - 3 => ::core::result::Result::Ok(Type::Log), + 0 => ::core::result::Result::Ok(SrtpCryptoSuite::AeadAes256Gcm), + 1 => ::core::result::Result::Ok(SrtpCryptoSuite::AeadAes128Gcm), + 2 => ::core::result::Result::Ok(SrtpCryptoSuite::AesCm128HmacSha180), + 3 => ::core::result::Result::Ok(SrtpCryptoSuite::AesCm128HmacSha132), _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { tag: value as i128, @@ -48085,19 +47595,19 @@ mod root { } } - impl ::core::convert::From for u8 { + impl ::core::convert::From for u8 { #[inline] - fn from(value: Type) -> Self { + fn from(value: SrtpCryptoSuite) -> Self { value as u8 } } - impl ::planus::Primitive for Type { + impl ::planus::Primitive for SrtpCryptoSuite { const ALIGNMENT: usize = 1; const SIZE: usize = 1; } - impl ::planus::WriteAsPrimitive for Type { + impl ::planus::WriteAsPrimitive for SrtpCryptoSuite { #[inline] fn write( &self, @@ -48108,24 +47618,24 @@ mod root { } } - impl ::planus::WriteAs for Type { + impl ::planus::WriteAs for SrtpCryptoSuite { type Prepared = Self; #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Type { + fn prepare(&self, _builder: &mut ::planus::Builder) -> SrtpCryptoSuite { *self } } - impl ::planus::WriteAsDefault for Type { + impl ::planus::WriteAsDefault for SrtpCryptoSuite { type Prepared = Self; #[inline] fn prepare( &self, _builder: &mut ::planus::Builder, - default: &Type, - ) -> ::core::option::Option { + default: &SrtpCryptoSuite, + ) -> ::core::option::Option { if self == default { ::core::option::Option::None } else { @@ -48134,19 +47644,19 @@ mod root { } } - impl ::planus::WriteAsOptional for Type { + impl ::planus::WriteAsOptional for SrtpCryptoSuite { type Prepared = Self; #[inline] fn prepare( &self, _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { + ) -> ::core::option::Option { ::core::option::Option::Some(*self) } } - impl<'buf> ::planus::TableRead<'buf> for Type { + impl<'buf> ::planus::TableRead<'buf> for SrtpCryptoSuite { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'buf>, @@ -48157,7 +47667,7 @@ mod root { } } - impl<'buf> ::planus::VectorReadInner<'buf> for Type { + impl<'buf> ::planus::VectorReadInner<'buf> for SrtpCryptoSuite { type Error = ::planus::errors::UnknownEnumTag; const STRIDE: usize = 1; #[inline] @@ -48171,7 +47681,7 @@ mod root { ::core::convert::TryInto::try_into(value); value.map_err(|error_kind| { error_kind.with_error_location( - "Type", + "SrtpCryptoSuite", "VectorRead::from_buffer", buffer.offset_from_start, ) @@ -48179,7 +47689,7 @@ mod root { } } - impl ::planus::VectorWrite for Type { + impl ::planus::VectorWrite for SrtpCryptoSuite { const STRIDE: usize = 1; type Value = Self; @@ -48206,512 +47716,251 @@ mod root { } } - /// The union `Body` in the namespace `FBS.Message` - /// - /// Generated from these locations: - /// * Union `Body` in the file `../worker/fbs/message.fbs:15` - #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, - )] - pub enum Body { - /// The variant of type `FBS.Request.Request` in the union `Body` - Request(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Response.Response` in the union `Body` - Response(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Notification.Notification` in the union `Body` - Notification(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Log.Log` in the union `Body` - Log(::planus::alloc::boxed::Box), - } - - impl Body { - /// Creates a [BodyBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> BodyBuilder<::planus::Uninitialized> { - BodyBuilder(::planus::Uninitialized) - } - - #[inline] - pub fn create_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_log( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) - } - } - - impl ::planus::WriteAsUnion for Body { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - match self { - Self::Request(value) => Self::create_request(builder, value), - Self::Response(value) => Self::create_response(builder, value), - Self::Notification(value) => Self::create_notification(builder, value), - Self::Log(value) => Self::create_log(builder, value), - } - } - } - - impl ::planus::WriteAsOptionalUnion for Body { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - - /// Builder for serializing an instance of the [Body] type. - /// - /// Can be created using the [Body::builder] method. - #[derive(Debug)] - #[must_use] - pub struct BodyBuilder(T); - - impl BodyBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`Request` variant](Body#variant.Request). - #[inline] - pub fn request(self, value: T) -> BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`Response` variant](Body#variant.Response). - #[inline] - pub fn response(self, value: T) -> BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`Notification` variant](Body#variant.Notification). - #[inline] - pub fn notification(self, value: T) -> BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`Log` variant](Body#variant.Log). - #[inline] - pub fn log(self, value: T) -> BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - } - - impl BodyBuilder<::planus::Initialized> { - /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. - #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset - where - Self: ::planus::WriteAsUnion, - { - ::planus::WriteAsUnion::prepare(&self, builder) - } - } - - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) - } - } - - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) - } - } - - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) - } - } - - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) - } - } - - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - - /// Reference to a deserialized [Body]. - #[derive(Copy, Clone, Debug)] - pub enum BodyRef<'a> { - Request(super::request::RequestRef<'a>), - Response(super::response::ResponseRef<'a>), - Notification(super::notification::NotificationRef<'a>), - Log(super::log::LogRef<'a>), - } - - impl<'a> ::core::convert::TryFrom> for Body { - type Error = ::planus::Error; - - fn try_from(value: BodyRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - BodyRef::Request(value) => Self::Request(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )), - - BodyRef::Response(value) => { - Self::Response(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::Notification(value) => { - Self::Notification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::Log(value) => Self::Log(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )), - }) - } - } - - impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, - ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::Request( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::Response( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 3 => ::core::result::Result::Ok(Self::Notification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 4 => ::core::result::Result::Ok(Self::Log( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), - } - } - } - - /// The table `Message` in the namespace `FBS.Message` + /// The table `SrtpParameters` in the namespace `FBS.SrtpParameters` /// /// Generated from these locations: - /// * Table `Message` in the file `../worker/fbs/message.fbs:22` + /// * Table `SrtpParameters` in the file `../worker/fbs/srtpParameters.fbs:11` #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] - pub struct Message { - /// The field `type` in the table `Message` - pub type_: self::Type, - /// The field `data` in the table `Message` - pub data: self::Body, + pub struct SrtpParameters { + /// The field `crypto_suite` in the table `SrtpParameters` + pub crypto_suite: self::SrtpCryptoSuite, + /// The field `key_base64` in the table `SrtpParameters` + pub key_base64: ::planus::alloc::string::String, } - impl Message { - /// Creates a [MessageBuilder] for serializing an instance of this table. + impl SrtpParameters { + /// Creates a [SrtpParametersBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> MessageBuilder<()> { - MessageBuilder(()) + pub fn builder() -> SrtpParametersBuilder<()> { + SrtpParametersBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_type_: impl ::planus::WriteAsDefault, - field_data: impl ::planus::WriteAsUnion, + field_crypto_suite: impl ::planus::WriteAsDefault< + self::SrtpCryptoSuite, + self::SrtpCryptoSuite, + >, + field_key_base64: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_type_ = field_type_.prepare(builder, &self::Type::Request); - let prepared_data = field_data.prepare(builder); + let prepared_crypto_suite = + field_crypto_suite.prepare(builder, &self::SrtpCryptoSuite::AeadAes256Gcm); + let prepared_key_base64 = field_key_base64.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(2); - if prepared_type_.is_some() { - table_writer.write_entry::(0); + table_writer.write_entry::<::planus::Offset>(1); + if prepared_crypto_suite.is_some() { + table_writer.write_entry::(0); } - table_writer.write_entry::(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_data.offset()); - if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { - object_writer.write::<_, _, 1>(&prepared_type_); + object_writer.write::<_, _, 4>(&prepared_key_base64); + if let ::core::option::Option::Some(prepared_crypto_suite) = + prepared_crypto_suite + { + object_writer.write::<_, _, 1>(&prepared_crypto_suite); } - object_writer.write::<_, _, 1>(&prepared_data.tag()); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for Message { + impl ::planus::WriteAs<::planus::Offset> for SrtpParameters { type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for Message { + impl ::planus::WriteAsOptional<::planus::Offset> for SrtpParameters { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for Message { + impl ::planus::WriteAsOffset for SrtpParameters { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - Message::create(builder, self.type_, &self.data) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + SrtpParameters::create(builder, self.crypto_suite, &self.key_base64) } } - /// Builder for serializing an instance of the [Message] type. + /// Builder for serializing an instance of the [SrtpParameters] type. /// - /// Can be created using the [Message::builder] method. + /// Can be created using the [SrtpParameters::builder] method. #[derive(Debug)] #[must_use] - pub struct MessageBuilder(State); + pub struct SrtpParametersBuilder(State); - impl MessageBuilder<()> { - /// Setter for the [`type` field](Message#structfield.type_). + impl SrtpParametersBuilder<()> { + /// Setter for the [`crypto_suite` field](SrtpParameters#structfield.crypto_suite). #[inline] #[allow(clippy::type_complexity)] - pub fn type_(self, value: T0) -> MessageBuilder<(T0,)> + pub fn crypto_suite(self, value: T0) -> SrtpParametersBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAsDefault, { - MessageBuilder((value,)) + SrtpParametersBuilder((value,)) } - /// Sets the [`type` field](Message#structfield.type_) to the default value. + /// Sets the [`crypto_suite` field](SrtpParameters#structfield.crypto_suite) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn type_as_default(self) -> MessageBuilder<(::planus::DefaultValue,)> { - self.type_(::planus::DefaultValue) + pub fn crypto_suite_as_default( + self, + ) -> SrtpParametersBuilder<(::planus::DefaultValue,)> { + self.crypto_suite(::planus::DefaultValue) } } - impl MessageBuilder<(T0,)> { - /// Setter for the [`data` field](Message#structfield.data). + impl SrtpParametersBuilder<(T0,)> { + /// Setter for the [`key_base64` field](SrtpParameters#structfield.key_base64). #[inline] #[allow(clippy::type_complexity)] - pub fn data(self, value: T1) -> MessageBuilder<(T0, T1)> + pub fn key_base64(self, value: T1) -> SrtpParametersBuilder<(T0, T1)> where - T1: ::planus::WriteAsUnion, + T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - MessageBuilder((v0, value)) + SrtpParametersBuilder((v0, value)) } } - impl MessageBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Message]. + impl SrtpParametersBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [SrtpParameters]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAs<::planus::Offset> for MessageBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> + for SrtpParametersBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAsOptional<::planus::Offset> - for MessageBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for SrtpParametersBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAsOffset for MessageBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset for SrtpParametersBuilder<(T0, T1)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { let (v0, v1) = &self.0; - Message::create(builder, v0, v1) + SrtpParameters::create(builder, v0, v1) } } - /// Reference to a deserialized [Message]. + /// Reference to a deserialized [SrtpParameters]. #[derive(Copy, Clone)] - pub struct MessageRef<'a>(::planus::table_reader::Table<'a>); + pub struct SrtpParametersRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> MessageRef<'a> { - /// Getter for the [`type` field](Message#structfield.type_). + impl<'a> SrtpParametersRef<'a> { + /// Getter for the [`crypto_suite` field](SrtpParameters#structfield.crypto_suite). #[inline] - pub fn type_(&self) -> ::planus::Result { + pub fn crypto_suite(&self) -> ::planus::Result { ::core::result::Result::Ok( self.0 - .access(0, "Message", "type_")? - .unwrap_or(self::Type::Request), + .access(0, "SrtpParameters", "crypto_suite")? + .unwrap_or(self::SrtpCryptoSuite::AeadAes256Gcm), ) } - /// Getter for the [`data` field](Message#structfield.data). + /// Getter for the [`key_base64` field](SrtpParameters#structfield.key_base64). #[inline] - pub fn data(&self) -> ::planus::Result> { - self.0.access_union_required(1, "Message", "data") + pub fn key_base64(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(1, "SrtpParameters", "key_base64") } } - impl<'a> ::core::fmt::Debug for MessageRef<'a> { + impl<'a> ::core::fmt::Debug for SrtpParametersRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("MessageRef"); - f.field("type_", &self.type_()); - f.field("data", &self.data()); + let mut f = f.debug_struct("SrtpParametersRef"); + f.field("crypto_suite", &self.crypto_suite()); + f.field("key_base64", &self.key_base64()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for Message { + impl<'a> ::core::convert::TryFrom> for SrtpParameters { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: MessageRef<'a>) -> ::planus::Result { + fn try_from(value: SrtpParametersRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - type_: ::core::convert::TryInto::try_into(value.type_()?)?, - data: ::core::convert::TryInto::try_into(value.data()?)?, + crypto_suite: ::core::convert::TryInto::try_into(value.crypto_suite()?)?, + key_base64: ::core::convert::TryInto::try_into(value.key_base64()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for MessageRef<'a> { + impl<'a> ::planus::TableRead<'a> for SrtpParametersRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -48723,7 +47972,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for MessageRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for SrtpParametersRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -48733,7 +47982,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[MessageRef]", + "[SrtpParametersRef]", "get", buffer.offset_from_start, ) @@ -48741,8 +47990,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for Message { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for SrtpParameters { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -48751,7 +48000,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -48766,7 +48015,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for MessageRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for SrtpParametersRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -48776,166 +48025,296 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[MessageRef]", "read_as_root", 0) + error_kind.with_error_location("[SrtpParametersRef]", "read_as_root", 0) }) } } } - /// The namespace `FBS.Notification` + /// The namespace `FBS.Log` /// /// Generated from these locations: - /// * File `../worker/fbs/notification.fbs` - pub mod notification { - /// The enum `Event` in the namespace `FBS.Notification` + /// * File `../worker/fbs/log.fbs` + pub mod log { + /// The table `Log` in the namespace `FBS.Log` /// /// Generated from these locations: - /// * Enum `Event` in the file `../worker/fbs/notification.fbs:13` + /// * Table `Log` in the file `../worker/fbs/log.fbs:4` #[derive( - Copy, Clone, Debug, PartialEq, - Eq, PartialOrd, + Eq, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - #[repr(u8)] - pub enum Event { - /// The variant `TRANSPORT_SEND_RTCP` in the enum `Event` - TransportSendRtcp = 0, - - /// The variant `PRODUCER_SEND` in the enum `Event` - ProducerSend = 1, - - /// The variant `DATAPRODUCER_SEND` in the enum `Event` - DataproducerSend = 2, + pub struct Log { + /// The field `data` in the table `Log` + pub data: ::planus::alloc::string::String, + } - /// The variant `WORKER_RUNNING` in the enum `Event` - WorkerRunning = 3, + impl Log { + /// Creates a [LogBuilder] for serializing an instance of this table. + #[inline] + pub fn builder() -> LogBuilder<()> { + LogBuilder(()) + } - /// The variant `TRANSPORT_SCTP_STATE_CHANGE` in the enum `Event` - TransportSctpStateChange = 4, + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_data: impl ::planus::WriteAs<::planus::Offset>, + ) -> ::planus::Offset { + let prepared_data = field_data.prepare(builder); - /// The variant `TRANSPORT_TRACE` in the enum `Event` - TransportTrace = 5, + let mut table_writer: ::planus::table_writer::TableWriter<6> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); - /// The variant `WEBRTCTRANSPORT_ICE_SELECTED_TUPLE_CHANGE` in the enum `Event` - WebrtctransportIceSelectedTupleChange = 6, + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_data); + }); + } + builder.current_offset() + } + } - /// The variant `WEBRTCTRANSPORT_ICE_STATE_CHANGE` in the enum `Event` - WebrtctransportIceStateChange = 7, + impl ::planus::WriteAs<::planus::Offset> for Log { + type Prepared = ::planus::Offset; - /// The variant `WEBRTCTRANSPORT_DTLS_STATE_CHANGE` in the enum `Event` - WebrtctransportDtlsStateChange = 8, + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) + } + } - /// The variant `PLAINTRANSPORT_TUPLE` in the enum `Event` - PlaintransportTuple = 9, + impl ::planus::WriteAsOptional<::planus::Offset> for Log { + type Prepared = ::planus::Offset; - /// The variant `PLAINTRANSPORT_RTCP_TUPLE` in the enum `Event` - PlaintransportRtcpTuple = 10, + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + } + } - /// The variant `DIRECTTRANSPORT_RTCP` in the enum `Event` - DirecttransportRtcp = 11, + impl ::planus::WriteAsOffset for Log { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + Log::create(builder, &self.data) + } + } - /// The variant `PRODUCER_SCORE` in the enum `Event` - ProducerScore = 12, + /// Builder for serializing an instance of the [Log] type. + /// + /// Can be created using the [Log::builder] method. + #[derive(Debug)] + #[must_use] + pub struct LogBuilder(State); - /// The variant `PRODUCER_TRACE` in the enum `Event` - ProducerTrace = 13, + impl LogBuilder<()> { + /// Setter for the [`data` field](Log#structfield.data). + #[inline] + #[allow(clippy::type_complexity)] + pub fn data(self, value: T0) -> LogBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + LogBuilder((value,)) + } + } - /// The variant `PRODUCER_VIDEO_ORIENTATION_CHANGE` in the enum `Event` - ProducerVideoOrientationChange = 14, + impl LogBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Log]. + #[inline] + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) + } + } - /// The variant `CONSUMER_PRODUCER_PAUSE` in the enum `Event` - ConsumerProducerPause = 15, + impl>> + ::planus::WriteAs<::planus::Offset> for LogBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// The variant `CONSUMER_PRODUCER_RESUME` in the enum `Event` - ConsumerProducerResume = 16, + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) + } + } - /// The variant `CONSUMER_PRODUCER_CLOSE` in the enum `Event` - ConsumerProducerClose = 17, + impl>> + ::planus::WriteAsOptional<::planus::Offset> for LogBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// The variant `CONSUMER_LAYERS_CHANGE` in the enum `Event` - ConsumerLayersChange = 18, + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + } + } - /// The variant `CONSUMER_RTP` in the enum `Event` - ConsumerRtp = 19, + impl>> ::planus::WriteAsOffset + for LogBuilder<(T0,)> + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + let (v0,) = &self.0; + Log::create(builder, v0) + } + } - /// The variant `CONSUMER_SCORE` in the enum `Event` - ConsumerScore = 20, + /// Reference to a deserialized [Log]. + #[derive(Copy, Clone)] + pub struct LogRef<'a>(::planus::table_reader::Table<'a>); - /// The variant `CONSUMER_TRACE` in the enum `Event` - ConsumerTrace = 21, + impl<'a> LogRef<'a> { + /// Getter for the [`data` field](Log#structfield.data). + #[inline] + pub fn data(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "Log", "data") + } + } - /// The variant `DATACONSUMER_BUFFERED_AMOUNT_LOW` in the enum `Event` - DataconsumerBufferedAmountLow = 22, + impl<'a> ::core::fmt::Debug for LogRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("LogRef"); + f.field("data", &self.data()); + f.finish() + } + } - /// The variant `DATACONSUMER_SCTP_SENDBUFFER_FULL` in the enum `Event` - DataconsumerSctpSendbufferFull = 23, + impl<'a> ::core::convert::TryFrom> for Log { + type Error = ::planus::Error; - /// The variant `DATACONSUMER_DATAPRODUCER_PAUSE` in the enum `Event` - DataconsumerDataproducerPause = 24, + #[allow(unreachable_code)] + fn try_from(value: LogRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + data: ::core::convert::TryInto::try_into(value.data()?)?, + }) + } + } - /// The variant `DATACONSUMER_DATAPRODUCER_RESUME` in the enum `Event` - DataconsumerDataproducerResume = 25, + impl<'a> ::planus::TableRead<'a> for LogRef<'a> { + #[inline] + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) + } + } - /// The variant `DATACONSUMER_DATAPRODUCER_CLOSE` in the enum `Event` - DataconsumerDataproducerClose = 26, + impl<'a> ::planus::VectorReadInner<'a> for LogRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; - /// The variant `DATACONSUMER_MESSAGE` in the enum `Event` - DataconsumerMessage = 27, + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location("[LogRef]", "get", buffer.offset_from_start) + }) + } + } - /// The variant `ACTIVESPEAKEROBSERVER_DOMINANT_SPEAKER` in the enum `Event` - ActivespeakerobserverDominantSpeaker = 28, + impl ::planus::VectorWrite<::planus::Offset> for Log { + type Value = ::planus::Offset; + const STRIDE: usize = 4; + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) + } - /// The variant `AUDIOLEVELOBSERVER_SILENCE` in the enum `Event` - AudiolevelobserverSilence = 29, + #[inline] + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } + } + } - /// The variant `AUDIOLEVELOBSERVER_VOLUMES` in the enum `Event` - AudiolevelobserverVolumes = 30, + impl<'a> ::planus::ReadAsRoot<'a> for LogRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[LogRef]", "read_as_root", 0) + }) + } + } + } + /// The namespace `FBS.Message` + /// + /// Generated from these locations: + /// * File `../worker/fbs/message.fbs` + pub mod message { + /// The enum `Type` in the namespace `FBS.Message` + /// + /// Generated from these locations: + /// * Enum `Type` in the file `../worker/fbs/message.fbs:8` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum Type { + /// The variant `REQUEST` in the enum `Type` + Request = 0, + + /// The variant `RESPONSE` in the enum `Type` + Response = 1, + + /// The variant `NOTIFICATION` in the enum `Type` + Notification = 2, + + /// The variant `LOG` in the enum `Type` + Log = 3, } - impl Event { - /// Array containing all valid variants of Event - pub const ENUM_VALUES: [Self; 31] = [ - Self::TransportSendRtcp, - Self::ProducerSend, - Self::DataproducerSend, - Self::WorkerRunning, - Self::TransportSctpStateChange, - Self::TransportTrace, - Self::WebrtctransportIceSelectedTupleChange, - Self::WebrtctransportIceStateChange, - Self::WebrtctransportDtlsStateChange, - Self::PlaintransportTuple, - Self::PlaintransportRtcpTuple, - Self::DirecttransportRtcp, - Self::ProducerScore, - Self::ProducerTrace, - Self::ProducerVideoOrientationChange, - Self::ConsumerProducerPause, - Self::ConsumerProducerResume, - Self::ConsumerProducerClose, - Self::ConsumerLayersChange, - Self::ConsumerRtp, - Self::ConsumerScore, - Self::ConsumerTrace, - Self::DataconsumerBufferedAmountLow, - Self::DataconsumerSctpSendbufferFull, - Self::DataconsumerDataproducerPause, - Self::DataconsumerDataproducerResume, - Self::DataconsumerDataproducerClose, - Self::DataconsumerMessage, - Self::ActivespeakerobserverDominantSpeaker, - Self::AudiolevelobserverSilence, - Self::AudiolevelobserverVolumes, - ]; + impl Type { + /// Array containing all valid variants of Type + pub const ENUM_VALUES: [Self; 4] = + [Self::Request, Self::Response, Self::Notification, Self::Log]; } - impl ::core::convert::TryFrom for Event { + impl ::core::convert::TryFrom for Type { type Error = ::planus::errors::UnknownEnumTagKind; #[inline] fn try_from( @@ -48944,41 +48323,10 @@ mod root { { #[allow(clippy::match_single_binding)] match value { - 0 => ::core::result::Result::Ok(Event::TransportSendRtcp), - 1 => ::core::result::Result::Ok(Event::ProducerSend), - 2 => ::core::result::Result::Ok(Event::DataproducerSend), - 3 => ::core::result::Result::Ok(Event::WorkerRunning), - 4 => ::core::result::Result::Ok(Event::TransportSctpStateChange), - 5 => ::core::result::Result::Ok(Event::TransportTrace), - 6 => { - ::core::result::Result::Ok(Event::WebrtctransportIceSelectedTupleChange) - } - 7 => ::core::result::Result::Ok(Event::WebrtctransportIceStateChange), - 8 => ::core::result::Result::Ok(Event::WebrtctransportDtlsStateChange), - 9 => ::core::result::Result::Ok(Event::PlaintransportTuple), - 10 => ::core::result::Result::Ok(Event::PlaintransportRtcpTuple), - 11 => ::core::result::Result::Ok(Event::DirecttransportRtcp), - 12 => ::core::result::Result::Ok(Event::ProducerScore), - 13 => ::core::result::Result::Ok(Event::ProducerTrace), - 14 => ::core::result::Result::Ok(Event::ProducerVideoOrientationChange), - 15 => ::core::result::Result::Ok(Event::ConsumerProducerPause), - 16 => ::core::result::Result::Ok(Event::ConsumerProducerResume), - 17 => ::core::result::Result::Ok(Event::ConsumerProducerClose), - 18 => ::core::result::Result::Ok(Event::ConsumerLayersChange), - 19 => ::core::result::Result::Ok(Event::ConsumerRtp), - 20 => ::core::result::Result::Ok(Event::ConsumerScore), - 21 => ::core::result::Result::Ok(Event::ConsumerTrace), - 22 => ::core::result::Result::Ok(Event::DataconsumerBufferedAmountLow), - 23 => ::core::result::Result::Ok(Event::DataconsumerSctpSendbufferFull), - 24 => ::core::result::Result::Ok(Event::DataconsumerDataproducerPause), - 25 => ::core::result::Result::Ok(Event::DataconsumerDataproducerResume), - 26 => ::core::result::Result::Ok(Event::DataconsumerDataproducerClose), - 27 => ::core::result::Result::Ok(Event::DataconsumerMessage), - 28 => { - ::core::result::Result::Ok(Event::ActivespeakerobserverDominantSpeaker) - } - 29 => ::core::result::Result::Ok(Event::AudiolevelobserverSilence), - 30 => ::core::result::Result::Ok(Event::AudiolevelobserverVolumes), + 0 => ::core::result::Result::Ok(Type::Request), + 1 => ::core::result::Result::Ok(Type::Response), + 2 => ::core::result::Result::Ok(Type::Notification), + 3 => ::core::result::Result::Ok(Type::Log), _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { tag: value as i128, @@ -48987,19 +48335,19 @@ mod root { } } - impl ::core::convert::From for u8 { + impl ::core::convert::From for u8 { #[inline] - fn from(value: Event) -> Self { + fn from(value: Type) -> Self { value as u8 } } - impl ::planus::Primitive for Event { + impl ::planus::Primitive for Type { const ALIGNMENT: usize = 1; const SIZE: usize = 1; } - impl ::planus::WriteAsPrimitive for Event { + impl ::planus::WriteAsPrimitive for Type { #[inline] fn write( &self, @@ -49010,24 +48358,24 @@ mod root { } } - impl ::planus::WriteAs for Event { + impl ::planus::WriteAs for Type { type Prepared = Self; #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Event { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Type { *self } } - impl ::planus::WriteAsDefault for Event { + impl ::planus::WriteAsDefault for Type { type Prepared = Self; #[inline] fn prepare( &self, _builder: &mut ::planus::Builder, - default: &Event, - ) -> ::core::option::Option { + default: &Type, + ) -> ::core::option::Option { if self == default { ::core::option::Option::None } else { @@ -49036,19 +48384,19 @@ mod root { } } - impl ::planus::WriteAsOptional for Event { + impl ::planus::WriteAsOptional for Type { type Prepared = Self; #[inline] fn prepare( &self, _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { + ) -> ::core::option::Option { ::core::option::Option::Some(*self) } } - impl<'buf> ::planus::TableRead<'buf> for Event { + impl<'buf> ::planus::TableRead<'buf> for Type { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'buf>, @@ -49059,7 +48407,7 @@ mod root { } } - impl<'buf> ::planus::VectorReadInner<'buf> for Event { + impl<'buf> ::planus::VectorReadInner<'buf> for Type { type Error = ::planus::errors::UnknownEnumTag; const STRIDE: usize = 1; #[inline] @@ -49073,7 +48421,7 @@ mod root { ::core::convert::TryInto::try_into(value); value.map_err(|error_kind| { error_kind.with_error_location( - "Event", + "Type", "VectorRead::from_buffer", buffer.offset_from_start, ) @@ -49081,7 +48429,7 @@ mod root { } } - impl ::planus::VectorWrite for Event { + impl ::planus::VectorWrite for Type { const STRIDE: usize = 1; type Value = Self; @@ -49108,117 +48456,25 @@ mod root { } } - /// The union `Body` in the namespace `FBS.Notification` + /// The union `Body` in the namespace `FBS.Message` /// /// Generated from these locations: - /// * Union `Body` in the file `../worker/fbs/notification.fbs:49` + /// * Union `Body` in the file `../worker/fbs/message.fbs:15` #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] pub enum Body { - /// The variant of type `FBS.Transport.SendRtcpNotification` in the union `Body` - SendRtcpNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.SctpStateChangeNotification` in the union `Body` - SctpStateChangeNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.DataProducer.SendNotification` in the union `Body` - SendNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.TraceNotification` in the union `Body` - TraceNotification(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.WebRtcTransport.IceSelectedTupleChangeNotification` in the union `Body` - IceSelectedTupleChangeNotification( - ::planus::alloc::boxed::Box< - super::web_rtc_transport::IceSelectedTupleChangeNotification, - >, - ), - - /// The variant of type `FBS.WebRtcTransport.IceStateChangeNotification` in the union `Body` - IceStateChangeNotification( - ::planus::alloc::boxed::Box< - super::web_rtc_transport::IceStateChangeNotification, - >, - ), - - /// The variant of type `FBS.WebRtcTransport.DtlsStateChangeNotification` in the union `Body` - DtlsStateChangeNotification( - ::planus::alloc::boxed::Box< - super::web_rtc_transport::DtlsStateChangeNotification, - >, - ), - - /// The variant of type `FBS.PlainTransport.TupleNotification` in the union `Body` - TupleNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.PlainTransport.RtcpTupleNotification` in the union `Body` - RtcpTupleNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.DirectTransport.RtcpNotification` in the union `Body` - RtcpNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.ScoreNotification` in the union `Body` - ScoreNotification(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Producer.VideoOrientationChangeNotification` in the union `Body` - VideoOrientationChangeNotification( - ::planus::alloc::boxed::Box< - super::producer::VideoOrientationChangeNotification, - >, - ), - - /// The variant of type `FBS.Consumer.LayersChangeNotification` in the union `Body` - LayersChangeNotification( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.RtpNotification` in the union `Body` - RtpNotification(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.DataConsumer.MessageNotification` in the union `Body` - MessageNotification( - ::planus::alloc::boxed::Box, - ), + /// The variant of type `FBS.Request.Request` in the union `Body` + Request(::planus::alloc::boxed::Box), - /// The variant of type `FBS.DataConsumer.BufferedAmountLowNotification` in the union `Body` - BufferedAmountLowNotification( - ::planus::alloc::boxed::Box< - super::data_consumer::BufferedAmountLowNotification, - >, - ), + /// The variant of type `FBS.Response.Response` in the union `Body` + Response(::planus::alloc::boxed::Box), - /// The variant of type `FBS.ActiveSpeakerObserver.DominantSpeakerNotification` in the union `Body` - DominantSpeakerNotification( - ::planus::alloc::boxed::Box< - super::active_speaker_observer::DominantSpeakerNotification, - >, - ), + /// The variant of type `FBS.Notification.Notification` in the union `Body` + Notification(::planus::alloc::boxed::Box), - /// The variant of type `FBS.AudioLevelObserver.VolumesNotification` in the union `Body` - VolumesNotification( - ::planus::alloc::boxed::Box, - ), + /// The variant of type `FBS.Log.Log` in the union `Body` + Log(::planus::alloc::boxed::Box), } impl Body { @@ -49229,222 +48485,46 @@ mod root { } #[inline] - pub fn create_send_rtcp_notification( + pub fn create_request( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, + value: impl ::planus::WriteAsOffset, ) -> ::planus::UnionOffset { ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) } #[inline] - pub fn create_sctp_state_change_notification( + pub fn create_response( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, + value: impl ::planus::WriteAsOffset, ) -> ::planus::UnionOffset { ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) } #[inline] - pub fn create_send_notification( + pub fn create_notification( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, + value: impl ::planus::WriteAsOffset, ) -> ::planus::UnionOffset { ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) } #[inline] - pub fn create_trace_notification( + pub fn create_log( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, + value: impl ::planus::WriteAsOffset, ) -> ::planus::UnionOffset { ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) } - - #[inline] - pub fn create_ice_selected_tuple_change_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::web_rtc_transport::IceSelectedTupleChangeNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_ice_state_change_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::web_rtc_transport::IceStateChangeNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_dtls_state_change_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::web_rtc_transport::DtlsStateChangeNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_tuple_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_rtcp_tuple_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_rtcp_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_score_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_video_orientation_change_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::producer::VideoOrientationChangeNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_layers_change_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_rtp_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_message_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_buffered_amount_low_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::data_consumer::BufferedAmountLowNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_dominant_speaker_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::active_speaker_observer::DominantSpeakerNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) - } - - #[inline] - pub fn create_volumes_notification( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::audio_level_observer::VolumesNotification, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) - } } impl ::planus::WriteAsUnion for Body { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { match self { - Self::SendRtcpNotification(value) => { - Self::create_send_rtcp_notification(builder, value) - } - Self::SctpStateChangeNotification(value) => { - Self::create_sctp_state_change_notification(builder, value) - } - Self::SendNotification(value) => { - Self::create_send_notification(builder, value) - } - Self::TraceNotification(value) => { - Self::create_trace_notification(builder, value) - } - Self::IceSelectedTupleChangeNotification(value) => { - Self::create_ice_selected_tuple_change_notification(builder, value) - } - Self::IceStateChangeNotification(value) => { - Self::create_ice_state_change_notification(builder, value) - } - Self::DtlsStateChangeNotification(value) => { - Self::create_dtls_state_change_notification(builder, value) - } - Self::TupleNotification(value) => { - Self::create_tuple_notification(builder, value) - } - Self::RtcpTupleNotification(value) => { - Self::create_rtcp_tuple_notification(builder, value) - } - Self::RtcpNotification(value) => { - Self::create_rtcp_notification(builder, value) - } - Self::ScoreNotification(value) => { - Self::create_score_notification(builder, value) - } - Self::VideoOrientationChangeNotification(value) => { - Self::create_video_orientation_change_notification(builder, value) - } - Self::LayersChangeNotification(value) => { - Self::create_layers_change_notification(builder, value) - } - Self::RtpNotification(value) => { - Self::create_rtp_notification(builder, value) - } - Self::MessageNotification(value) => { - Self::create_message_notification(builder, value) - } - Self::BufferedAmountLowNotification(value) => { - Self::create_buffered_amount_low_notification(builder, value) - } - Self::DominantSpeakerNotification(value) => { - Self::create_dominant_speaker_notification(builder, value) - } - Self::VolumesNotification(value) => { - Self::create_volumes_notification(builder, value) - } + Self::Request(value) => Self::create_request(builder, value), + Self::Response(value) => Self::create_response(builder, value), + Self::Notification(value) => Self::create_notification(builder, value), + Self::Log(value) => Self::create_log(builder, value), } } } @@ -49467,226 +48547,38 @@ mod root { pub struct BodyBuilder(T); impl BodyBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`SendRtcpNotification` variant](Body#variant.SendRtcpNotification). - #[inline] - pub fn send_rtcp_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`SctpStateChangeNotification` variant](Body#variant.SctpStateChangeNotification). - #[inline] - pub fn sctp_state_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`SendNotification` variant](Body#variant.SendNotification). - #[inline] - pub fn send_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`TraceNotification` variant](Body#variant.TraceNotification). - #[inline] - pub fn trace_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`IceSelectedTupleChangeNotification` variant](Body#variant.IceSelectedTupleChangeNotification). - #[inline] - pub fn ice_selected_tuple_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset< - super::web_rtc_transport::IceSelectedTupleChangeNotification, - >, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`IceStateChangeNotification` variant](Body#variant.IceStateChangeNotification). - #[inline] - pub fn ice_state_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset< - super::web_rtc_transport::IceStateChangeNotification, - >, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`DtlsStateChangeNotification` variant](Body#variant.DtlsStateChangeNotification). - #[inline] - pub fn dtls_state_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset< - super::web_rtc_transport::DtlsStateChangeNotification, - >, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`TupleNotification` variant](Body#variant.TupleNotification). - #[inline] - pub fn tuple_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`RtcpTupleNotification` variant](Body#variant.RtcpTupleNotification). - #[inline] - pub fn rtcp_tuple_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`RtcpNotification` variant](Body#variant.RtcpNotification). - #[inline] - pub fn rtcp_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`ScoreNotification` variant](Body#variant.ScoreNotification). - #[inline] - pub fn score_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`VideoOrientationChangeNotification` variant](Body#variant.VideoOrientationChangeNotification). - #[inline] - pub fn video_orientation_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`LayersChangeNotification` variant](Body#variant.LayersChangeNotification). - #[inline] - pub fn layers_change_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`RtpNotification` variant](Body#variant.RtpNotification). - #[inline] - pub fn rtp_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`MessageNotification` variant](Body#variant.MessageNotification). + /// Creates an instance of the [`Request` variant](Body#variant.Request). #[inline] - pub fn message_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<15, T>> + pub fn request(self, value: T) -> BodyBuilder<::planus::Initialized<1, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { BodyBuilder(::planus::Initialized(value)) } - /// Creates an instance of the [`BufferedAmountLowNotification` variant](Body#variant.BufferedAmountLowNotification). + /// Creates an instance of the [`Response` variant](Body#variant.Response). #[inline] - pub fn buffered_amount_low_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<16, T>> + pub fn response(self, value: T) -> BodyBuilder<::planus::Initialized<2, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { BodyBuilder(::planus::Initialized(value)) } - /// Creates an instance of the [`DominantSpeakerNotification` variant](Body#variant.DominantSpeakerNotification). + /// Creates an instance of the [`Notification` variant](Body#variant.Notification). #[inline] - pub fn dominant_speaker_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<17, T>> + pub fn notification(self, value: T) -> BodyBuilder<::planus::Initialized<3, T>> where - T: ::planus::WriteAsOffset< - super::active_speaker_observer::DominantSpeakerNotification, - >, + T: ::planus::WriteAsOffset, { BodyBuilder(::planus::Initialized(value)) } - /// Creates an instance of the [`VolumesNotification` variant](Body#variant.VolumesNotification). + /// Creates an instance of the [`Log` variant](Body#variant.Log). #[inline] - pub fn volumes_notification( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<18, T>> + pub fn log(self, value: T) -> BodyBuilder<::planus::Initialized<4, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { BodyBuilder(::planus::Initialized(value)) } @@ -49705,7 +48597,7 @@ mod root { impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { @@ -49715,7 +48607,7 @@ mod root { impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -49727,7 +48619,7 @@ mod root { } impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { @@ -49737,7 +48629,7 @@ mod root { impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -49749,7 +48641,7 @@ mod root { } impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { @@ -49759,7 +48651,7 @@ mod root { impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -49771,7 +48663,7 @@ mod root { } impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { @@ -49781,7 +48673,7 @@ mod root { impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -49791,3088 +48683,3832 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset< - super::web_rtc_transport::IceSelectedTupleChangeNotification, - >, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) - } + + /// Reference to a deserialized [Body]. + #[derive(Copy, Clone, Debug)] + pub enum BodyRef<'a> { + Request(super::request::RequestRef<'a>), + Response(super::response::ResponseRef<'a>), + Notification(super::notification::NotificationRef<'a>), + Log(super::log::LogRef<'a>), } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset< - super::web_rtc_transport::IceSelectedTupleChangeNotification, - >, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::core::convert::TryFrom> for Body { + type Error = ::planus::Error; + + fn try_from(value: BodyRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + BodyRef::Request(value) => Self::Request(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )), + + BodyRef::Response(value) => { + Self::Response(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::Notification(value) => { + Self::Notification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::Log(value) => Self::Log(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )), + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + field_offset: usize, + tag: u8, + ) -> ::core::result::Result { + match tag { + 1 => ::core::result::Result::Ok(Self::Request( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::Response( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 3 => ::core::result::Result::Ok(Self::Notification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 4 => ::core::result::Result::Ok(Self::Log( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), + } } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) - } + /// The table `Message` in the namespace `FBS.Message` + /// + /// Generated from these locations: + /// * Table `Message` in the file `../worker/fbs/message.fbs:22` + #[derive( + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + )] + pub struct Message { + /// The field `type` in the table `Message` + pub type_: self::Type, + /// The field `data` in the table `Message` + pub data: self::Body, } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { + impl Message { + /// Creates a [MessageBuilder] for serializing an instance of this table. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) + pub fn builder() -> MessageBuilder<()> { + MessageBuilder(()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, + #[allow(clippy::too_many_arguments)] + pub fn create( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + field_type_: impl ::planus::WriteAsDefault, + field_data: impl ::planus::WriteAsUnion, + ) -> ::planus::Offset { + let prepared_type_ = field_type_.prepare(builder, &self::Type::Request); + let prepared_data = field_data.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<10> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(2); + if prepared_type_.is_some() { + table_writer.write_entry::(0); + } + table_writer.write_entry::(1); + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_data.offset()); + if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { + object_writer.write::<_, _, 1>(&prepared_type_); + } + object_writer.write::<_, _, 1>(&prepared_data.tag()); + }); + } + builder.current_offset() } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::WriteAs<::planus::Offset> for Message { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptional<::planus::Offset> for Message { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOffset for Message { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + Message::create(builder, self.type_, &self.data) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Builder for serializing an instance of the [Message] type. + /// + /// Can be created using the [Message::builder] method. + #[derive(Debug)] + #[must_use] + pub struct MessageBuilder(State); + + impl MessageBuilder<()> { + /// Setter for the [`type` field](Message#structfield.type_). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn type_(self, value: T0) -> MessageBuilder<(T0,)> + where + T0: ::planus::WriteAsDefault, + { + MessageBuilder((value,)) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { + /// Sets the [`type` field](Message#structfield.type_) to the default value. #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + #[allow(clippy::type_complexity)] + pub fn type_as_default(self) -> MessageBuilder<(::planus::DefaultValue,)> { + self.type_(::planus::DefaultValue) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { + + impl MessageBuilder<(T0,)> { + /// Setter for the [`data` field](Message#structfield.data). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn data(self, value: T1) -> MessageBuilder<(T0, T1)> + where + T1: ::planus::WriteAsUnion, + { + let (v0,) = self.0; + MessageBuilder((v0, value)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { + impl MessageBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Message]. #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAs<::planus::Offset> for MessageBuilder<(T0, T1)> { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAsOptional<::planus::Offset> + for MessageBuilder<(T0, T1)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAsOffset for MessageBuilder<(T0, T1)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + let (v0, v1) = &self.0; + Message::create(builder, v0, v1) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { + /// Reference to a deserialized [Message]. + #[derive(Copy, Clone)] + pub struct MessageRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> MessageRef<'a> { + /// Getter for the [`type` field](Message#structfield.type_). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn type_(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "Message", "type_")? + .unwrap_or(self::Type::Request), + ) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Getter for the [`data` field](Message#structfield.data). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) + pub fn data(&self) -> ::planus::Result> { + self.0.access_union_required(1, "Message", "data") } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::core::fmt::Debug for MessageRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("MessageRef"); + f.field("type_", &self.type_()); + f.field("data", &self.data()); + f.finish() } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::core::convert::TryFrom> for Message { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: MessageRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + type_: ::core::convert::TryInto::try_into(value.type_()?)?, + data: ::core::convert::TryInto::try_into(value.data()?)?, + }) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { + impl<'a> ::planus::TableRead<'a> for MessageRef<'a> { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset< - super::active_speaker_observer::DominantSpeakerNotification, - >, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::planus::VectorReadInner<'a> for MessageRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[MessageRef]", + "get", + buffer.offset_from_start, + ) + }) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset< - super::active_speaker_observer::DominantSpeakerNotification, - >, - { + impl ::planus::VectorWrite<::planus::Offset> for Message { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::planus::ReadAsRoot<'a> for MessageRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[MessageRef]", "read_as_root", 0) + }) } } + } + /// The namespace `FBS.Notification` + /// + /// Generated from these locations: + /// * File `../worker/fbs/notification.fbs` + pub mod notification { + /// The enum `Event` in the namespace `FBS.Notification` + /// + /// Generated from these locations: + /// * Enum `Event` in the file `../worker/fbs/notification.fbs:13` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum Event { + /// The variant `TRANSPORT_SEND_RTCP` in the enum `Event` + TransportSendRtcp = 0, - /// Reference to a deserialized [Body]. - #[derive(Copy, Clone, Debug)] - pub enum BodyRef<'a> { - SendRtcpNotification(super::transport::SendRtcpNotificationRef<'a>), - SctpStateChangeNotification(super::transport::SctpStateChangeNotificationRef<'a>), - SendNotification(super::data_producer::SendNotificationRef<'a>), - TraceNotification(super::consumer::TraceNotificationRef<'a>), - IceSelectedTupleChangeNotification( - super::web_rtc_transport::IceSelectedTupleChangeNotificationRef<'a>, - ), - IceStateChangeNotification( - super::web_rtc_transport::IceStateChangeNotificationRef<'a>, - ), - DtlsStateChangeNotification( - super::web_rtc_transport::DtlsStateChangeNotificationRef<'a>, - ), - TupleNotification(super::plain_transport::TupleNotificationRef<'a>), - RtcpTupleNotification(super::plain_transport::RtcpTupleNotificationRef<'a>), - RtcpNotification(super::direct_transport::RtcpNotificationRef<'a>), - ScoreNotification(super::consumer::ScoreNotificationRef<'a>), - VideoOrientationChangeNotification( - super::producer::VideoOrientationChangeNotificationRef<'a>, - ), - LayersChangeNotification(super::consumer::LayersChangeNotificationRef<'a>), - RtpNotification(super::consumer::RtpNotificationRef<'a>), - MessageNotification(super::data_consumer::MessageNotificationRef<'a>), - BufferedAmountLowNotification( - super::data_consumer::BufferedAmountLowNotificationRef<'a>, - ), - DominantSpeakerNotification( - super::active_speaker_observer::DominantSpeakerNotificationRef<'a>, - ), - VolumesNotification(super::audio_level_observer::VolumesNotificationRef<'a>), - } + /// The variant `PRODUCER_SEND` in the enum `Event` + ProducerSend = 1, - impl<'a> ::core::convert::TryFrom> for Body { - type Error = ::planus::Error; + /// The variant `DATAPRODUCER_SEND` in the enum `Event` + DataproducerSend = 2, - fn try_from(value: BodyRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - BodyRef::SendRtcpNotification(value) => { - Self::SendRtcpNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `WORKER_RUNNING` in the enum `Event` + WorkerRunning = 3, - BodyRef::SctpStateChangeNotification(value) => { - Self::SctpStateChangeNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `TRANSPORT_SCTP_STATE_CHANGE` in the enum `Event` + TransportSctpStateChange = 4, - BodyRef::SendNotification(value) => { - Self::SendNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `TRANSPORT_TRACE` in the enum `Event` + TransportTrace = 5, - BodyRef::TraceNotification(value) => { - Self::TraceNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `WEBRTCTRANSPORT_ICE_SELECTED_TUPLE_CHANGE` in the enum `Event` + WebrtctransportIceSelectedTupleChange = 6, - BodyRef::IceSelectedTupleChangeNotification(value) => { - Self::IceSelectedTupleChangeNotification( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } + /// The variant `WEBRTCTRANSPORT_ICE_STATE_CHANGE` in the enum `Event` + WebrtctransportIceStateChange = 7, - BodyRef::IceStateChangeNotification(value) => { - Self::IceStateChangeNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `WEBRTCTRANSPORT_DTLS_STATE_CHANGE` in the enum `Event` + WebrtctransportDtlsStateChange = 8, - BodyRef::DtlsStateChangeNotification(value) => { - Self::DtlsStateChangeNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `PLAINTRANSPORT_TUPLE` in the enum `Event` + PlaintransportTuple = 9, - BodyRef::TupleNotification(value) => { - Self::TupleNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `PLAINTRANSPORT_RTCP_TUPLE` in the enum `Event` + PlaintransportRtcpTuple = 10, - BodyRef::RtcpTupleNotification(value) => { - Self::RtcpTupleNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `DIRECTTRANSPORT_RTCP` in the enum `Event` + DirecttransportRtcp = 11, - BodyRef::RtcpNotification(value) => { - Self::RtcpNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `PRODUCER_SCORE` in the enum `Event` + ProducerScore = 12, - BodyRef::ScoreNotification(value) => { - Self::ScoreNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `PRODUCER_TRACE` in the enum `Event` + ProducerTrace = 13, - BodyRef::VideoOrientationChangeNotification(value) => { - Self::VideoOrientationChangeNotification( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } + /// The variant `PRODUCER_VIDEO_ORIENTATION_CHANGE` in the enum `Event` + ProducerVideoOrientationChange = 14, - BodyRef::LayersChangeNotification(value) => { - Self::LayersChangeNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `CONSUMER_PRODUCER_PAUSE` in the enum `Event` + ConsumerProducerPause = 15, - BodyRef::RtpNotification(value) => { - Self::RtpNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `CONSUMER_PRODUCER_RESUME` in the enum `Event` + ConsumerProducerResume = 16, - BodyRef::MessageNotification(value) => { - Self::MessageNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `CONSUMER_PRODUCER_CLOSE` in the enum `Event` + ConsumerProducerClose = 17, - BodyRef::BufferedAmountLowNotification(value) => { - Self::BufferedAmountLowNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `CONSUMER_LAYERS_CHANGE` in the enum `Event` + ConsumerLayersChange = 18, - BodyRef::DominantSpeakerNotification(value) => { - Self::DominantSpeakerNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// The variant `CONSUMER_RTP` in the enum `Event` + ConsumerRtp = 19, - BodyRef::VolumesNotification(value) => { - Self::VolumesNotification(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - }) - } - } + /// The variant `CONSUMER_SCORE` in the enum `Event` + ConsumerScore = 20, - impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, - ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::SendRtcpNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::SctpStateChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 3 => ::core::result::Result::Ok(Self::SendNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 4 => ::core::result::Result::Ok(Self::TraceNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 5 => ::core::result::Result::Ok(Self::IceSelectedTupleChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 6 => ::core::result::Result::Ok(Self::IceStateChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 7 => ::core::result::Result::Ok(Self::DtlsStateChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 8 => ::core::result::Result::Ok(Self::TupleNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 9 => ::core::result::Result::Ok(Self::RtcpTupleNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 10 => ::core::result::Result::Ok(Self::RtcpNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 11 => ::core::result::Result::Ok(Self::ScoreNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 12 => ::core::result::Result::Ok(Self::VideoOrientationChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 13 => ::core::result::Result::Ok(Self::LayersChangeNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 14 => ::core::result::Result::Ok(Self::RtpNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 15 => ::core::result::Result::Ok(Self::MessageNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 16 => ::core::result::Result::Ok(Self::BufferedAmountLowNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 17 => ::core::result::Result::Ok(Self::DominantSpeakerNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 18 => ::core::result::Result::Ok(Self::VolumesNotification( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), - } - } - } + /// The variant `CONSUMER_TRACE` in the enum `Event` + ConsumerTrace = 21, - /// The table `Notification` in the namespace `FBS.Notification` - /// - /// Generated from these locations: - /// * Table `Notification` in the file `../worker/fbs/notification.fbs:76` - #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - pub struct Notification { - /// The field `handler_id` in the table `Notification` - pub handler_id: ::planus::alloc::string::String, - /// The field `event` in the table `Notification` - pub event: self::Event, - /// The field `body` in the table `Notification` - pub body: ::core::option::Option, - } + /// The variant `DATACONSUMER_BUFFERED_AMOUNT_LOW` in the enum `Event` + DataconsumerBufferedAmountLow = 22, - impl Notification { - /// Creates a [NotificationBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> NotificationBuilder<()> { - NotificationBuilder(()) - } + /// The variant `DATACONSUMER_SCTP_SENDBUFFER_FULL` in the enum `Event` + DataconsumerSctpSendbufferFull = 23, - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_handler_id: impl ::planus::WriteAs<::planus::Offset>, - field_event: impl ::planus::WriteAsDefault, - field_body: impl ::planus::WriteAsOptionalUnion, - ) -> ::planus::Offset { - let prepared_handler_id = field_handler_id.prepare(builder); - let prepared_event = - field_event.prepare(builder, &self::Event::TransportSendRtcp); - let prepared_body = field_body.prepare(builder); + /// The variant `DATACONSUMER_DATAPRODUCER_PAUSE` in the enum `Event` + DataconsumerDataproducerPause = 24, - let mut table_writer: ::planus::table_writer::TableWriter<12> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - if prepared_body.is_some() { - table_writer.write_entry::<::planus::Offset>(3); - } - if prepared_event.is_some() { - table_writer.write_entry::(1); - } - if prepared_body.is_some() { - table_writer.write_entry::(2); - } + /// The variant `DATACONSUMER_DATAPRODUCER_RESUME` in the enum `Event` + DataconsumerDataproducerResume = 25, - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_handler_id); - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 4>(&prepared_body.offset()); - } - if let ::core::option::Option::Some(prepared_event) = prepared_event { - object_writer.write::<_, _, 1>(&prepared_event); - } - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 1>(&prepared_body.tag()); - } - }); - } - builder.current_offset() - } - } + /// The variant `DATACONSUMER_DATAPRODUCER_CLOSE` in the enum `Event` + DataconsumerDataproducerClose = 26, - impl ::planus::WriteAs<::planus::Offset> for Notification { - type Prepared = ::planus::Offset; + /// The variant `DATACONSUMER_MESSAGE` in the enum `Event` + DataconsumerMessage = 27, - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } + /// The variant `ACTIVESPEAKEROBSERVER_DOMINANT_SPEAKER` in the enum `Event` + ActivespeakerobserverDominantSpeaker = 28, - impl ::planus::WriteAsOptional<::planus::Offset> for Notification { - type Prepared = ::planus::Offset; + /// The variant `AUDIOLEVELOBSERVER_SILENCE` in the enum `Event` + AudiolevelobserverSilence = 29, - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } + /// The variant `AUDIOLEVELOBSERVER_VOLUMES` in the enum `Event` + AudiolevelobserverVolumes = 30, } - impl ::planus::WriteAsOffset for Notification { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - Notification::create(builder, &self.handler_id, self.event, &self.body) - } + impl Event { + /// Array containing all valid variants of Event + pub const ENUM_VALUES: [Self; 31] = [ + Self::TransportSendRtcp, + Self::ProducerSend, + Self::DataproducerSend, + Self::WorkerRunning, + Self::TransportSctpStateChange, + Self::TransportTrace, + Self::WebrtctransportIceSelectedTupleChange, + Self::WebrtctransportIceStateChange, + Self::WebrtctransportDtlsStateChange, + Self::PlaintransportTuple, + Self::PlaintransportRtcpTuple, + Self::DirecttransportRtcp, + Self::ProducerScore, + Self::ProducerTrace, + Self::ProducerVideoOrientationChange, + Self::ConsumerProducerPause, + Self::ConsumerProducerResume, + Self::ConsumerProducerClose, + Self::ConsumerLayersChange, + Self::ConsumerRtp, + Self::ConsumerScore, + Self::ConsumerTrace, + Self::DataconsumerBufferedAmountLow, + Self::DataconsumerSctpSendbufferFull, + Self::DataconsumerDataproducerPause, + Self::DataconsumerDataproducerResume, + Self::DataconsumerDataproducerClose, + Self::DataconsumerMessage, + Self::ActivespeakerobserverDominantSpeaker, + Self::AudiolevelobserverSilence, + Self::AudiolevelobserverVolumes, + ]; } - /// Builder for serializing an instance of the [Notification] type. - /// - /// Can be created using the [Notification::builder] method. - #[derive(Debug)] - #[must_use] - pub struct NotificationBuilder(State); - - impl NotificationBuilder<()> { - /// Setter for the [`handler_id` field](Notification#structfield.handler_id). + impl ::core::convert::TryFrom for Event { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - #[allow(clippy::type_complexity)] - pub fn handler_id(self, value: T0) -> NotificationBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, + fn try_from( + value: u8, + ) -> ::core::result::Result { - NotificationBuilder((value,)) - } - } + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(Event::TransportSendRtcp), + 1 => ::core::result::Result::Ok(Event::ProducerSend), + 2 => ::core::result::Result::Ok(Event::DataproducerSend), + 3 => ::core::result::Result::Ok(Event::WorkerRunning), + 4 => ::core::result::Result::Ok(Event::TransportSctpStateChange), + 5 => ::core::result::Result::Ok(Event::TransportTrace), + 6 => { + ::core::result::Result::Ok(Event::WebrtctransportIceSelectedTupleChange) + } + 7 => ::core::result::Result::Ok(Event::WebrtctransportIceStateChange), + 8 => ::core::result::Result::Ok(Event::WebrtctransportDtlsStateChange), + 9 => ::core::result::Result::Ok(Event::PlaintransportTuple), + 10 => ::core::result::Result::Ok(Event::PlaintransportRtcpTuple), + 11 => ::core::result::Result::Ok(Event::DirecttransportRtcp), + 12 => ::core::result::Result::Ok(Event::ProducerScore), + 13 => ::core::result::Result::Ok(Event::ProducerTrace), + 14 => ::core::result::Result::Ok(Event::ProducerVideoOrientationChange), + 15 => ::core::result::Result::Ok(Event::ConsumerProducerPause), + 16 => ::core::result::Result::Ok(Event::ConsumerProducerResume), + 17 => ::core::result::Result::Ok(Event::ConsumerProducerClose), + 18 => ::core::result::Result::Ok(Event::ConsumerLayersChange), + 19 => ::core::result::Result::Ok(Event::ConsumerRtp), + 20 => ::core::result::Result::Ok(Event::ConsumerScore), + 21 => ::core::result::Result::Ok(Event::ConsumerTrace), + 22 => ::core::result::Result::Ok(Event::DataconsumerBufferedAmountLow), + 23 => ::core::result::Result::Ok(Event::DataconsumerSctpSendbufferFull), + 24 => ::core::result::Result::Ok(Event::DataconsumerDataproducerPause), + 25 => ::core::result::Result::Ok(Event::DataconsumerDataproducerResume), + 26 => ::core::result::Result::Ok(Event::DataconsumerDataproducerClose), + 27 => ::core::result::Result::Ok(Event::DataconsumerMessage), + 28 => { + ::core::result::Result::Ok(Event::ActivespeakerobserverDominantSpeaker) + } + 29 => ::core::result::Result::Ok(Event::AudiolevelobserverSilence), + 30 => ::core::result::Result::Ok(Event::AudiolevelobserverVolumes), - impl NotificationBuilder<(T0,)> { - /// Setter for the [`event` field](Notification#structfield.event). - #[inline] - #[allow(clippy::type_complexity)] - pub fn event(self, value: T1) -> NotificationBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault, - { - let (v0,) = self.0; - NotificationBuilder((v0, value)) + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } + } - /// Sets the [`event` field](Notification#structfield.event) to the default value. + impl ::core::convert::From for u8 { #[inline] - #[allow(clippy::type_complexity)] - pub fn event_as_default(self) -> NotificationBuilder<(T0, ::planus::DefaultValue)> { - self.event(::planus::DefaultValue) + fn from(value: Event) -> Self { + value as u8 } } - impl NotificationBuilder<(T0, T1)> { - /// Setter for the [`body` field](Notification#structfield.body). - #[inline] - #[allow(clippy::type_complexity)] - pub fn body(self, value: T2) -> NotificationBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsOptionalUnion, - { - let (v0, v1) = self.0; - NotificationBuilder((v0, v1, value)) - } + impl ::planus::Primitive for Event { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } - /// Sets the [`body` field](Notification#structfield.body) to null. + impl ::planus::WriteAsPrimitive for Event { #[inline] - #[allow(clippy::type_complexity)] - pub fn body_as_null(self) -> NotificationBuilder<(T0, T1, ())> { - self.body(()) + fn write( + &self, + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl NotificationBuilder<(T0, T1, T2)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Notification]. + impl ::planus::WriteAs for Event { + type Prepared = Self; + #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Event { + *self } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAs<::planus::Offset> - for NotificationBuilder<(T0, T1, T2)> - { - type Prepared = ::planus::Offset; + impl ::planus::WriteAsDefault for Event { + type Prepared = Self; #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + _builder: &mut ::planus::Builder, + default: &Event, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOptional<::planus::Offset> - for NotificationBuilder<(T0, T1, T2)> - { - type Prepared = ::planus::Offset; + impl ::planus::WriteAsOptional for Event { + type Prepared = Self; #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOffset for NotificationBuilder<(T0, T1, T2)> - { + impl<'buf> ::planus::TableRead<'buf> for Event { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - Notification::create(builder, v0, v1, v2) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - /// Reference to a deserialized [Notification]. - #[derive(Copy, Clone)] - pub struct NotificationRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> NotificationRef<'a> { - /// Getter for the [`handler_id` field](Notification#structfield.handler_id). + impl<'buf> ::planus::VectorReadInner<'buf> for Event { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - pub fn handler_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "Notification", "handler_id") - } - - /// Getter for the [`event` field](Notification#structfield.event). - #[inline] - pub fn event(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "Notification", "event")? - .unwrap_or(self::Event::TransportSendRtcp), - ) - } - - /// Getter for the [`body` field](Notification#structfield.body). - #[inline] - pub fn body(&self) -> ::planus::Result<::core::option::Option>> { - self.0.access_union(2, "Notification", "body") - } - } - - impl<'a> ::core::fmt::Debug for NotificationRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("NotificationRef"); - f.field("handler_id", &self.handler_id()); - f.field("event", &self.event()); - if let ::core::option::Option::Some(field_body) = self.body().transpose() { - f.field("body", &field_body); - } - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for Notification { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: NotificationRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - handler_id: ::core::convert::TryInto::try_into(value.handler_id()?)?, - event: ::core::convert::TryInto::try_into(value.event()?)?, - body: if let ::core::option::Option::Some(body) = value.body()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) - } else { - ::core::option::Option::None - }, - }) - } - } - - impl<'a> ::planus::TableRead<'a> for NotificationRef<'a> { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "Event", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } } - impl<'a> ::planus::VectorReadInner<'a> for NotificationRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for Event { + const STRIDE: usize = 1; - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[NotificationRef]", - "get", - buffer.offset_from_start, - ) - }) - } - } + type Value = Self; - impl ::planus::VectorWrite<::planus::Offset> for Notification { - type Value = ::planus::Offset; - const STRIDE: usize = 4; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for NotificationRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[NotificationRef]", "read_as_root", 0) - }) - } - } - } - /// The namespace `FBS.Request` - /// - /// Generated from these locations: - /// * File `../worker/fbs/request.fbs` - pub mod request { - /// The enum `Method` in the namespace `FBS.Request` + /// The union `Body` in the namespace `FBS.Notification` /// /// Generated from these locations: - /// * Enum `Method` in the file `../worker/fbs/request.fbs:11` + /// * Union `Body` in the file `../worker/fbs/notification.fbs:49` #[derive( - Copy, Clone, Debug, PartialEq, - Eq, PartialOrd, + Eq, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - #[repr(u8)] - pub enum Method { - /// The variant `WORKER_CLOSE` in the enum `Method` - WorkerClose = 0, - - /// The variant `WORKER_DUMP` in the enum `Method` - WorkerDump = 1, - - /// The variant `WORKER_GET_RESOURCE_USAGE` in the enum `Method` - WorkerGetResourceUsage = 2, - - /// The variant `WORKER_UPDATE_SETTINGS` in the enum `Method` - WorkerUpdateSettings = 3, + pub enum Body { + /// The variant of type `FBS.Transport.SendRtcpNotification` in the union `Body` + SendRtcpNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `WORKER_CREATE_WEBRTCSERVER` in the enum `Method` - WorkerCreateWebrtcserver = 4, + /// The variant of type `FBS.Transport.SctpStateChangeNotification` in the union `Body` + SctpStateChangeNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `WORKER_CREATE_ROUTER` in the enum `Method` - WorkerCreateRouter = 5, + /// The variant of type `FBS.DataProducer.SendNotification` in the union `Body` + SendNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `WORKER_WEBRTCSERVER_CLOSE` in the enum `Method` - WorkerWebrtcserverClose = 6, + /// The variant of type `FBS.Consumer.TraceNotification` in the union `Body` + TraceNotification(::planus::alloc::boxed::Box), - /// The variant `WORKER_CLOSE_ROUTER` in the enum `Method` - WorkerCloseRouter = 7, + /// The variant of type `FBS.WebRtcTransport.IceSelectedTupleChangeNotification` in the union `Body` + IceSelectedTupleChangeNotification( + ::planus::alloc::boxed::Box< + super::web_rtc_transport::IceSelectedTupleChangeNotification, + >, + ), - /// The variant `WEBRTCSERVER_DUMP` in the enum `Method` - WebrtcserverDump = 8, + /// The variant of type `FBS.WebRtcTransport.IceStateChangeNotification` in the union `Body` + IceStateChangeNotification( + ::planus::alloc::boxed::Box< + super::web_rtc_transport::IceStateChangeNotification, + >, + ), - /// The variant `ROUTER_DUMP` in the enum `Method` - RouterDump = 9, + /// The variant of type `FBS.WebRtcTransport.DtlsStateChangeNotification` in the union `Body` + DtlsStateChangeNotification( + ::planus::alloc::boxed::Box< + super::web_rtc_transport::DtlsStateChangeNotification, + >, + ), - /// The variant `ROUTER_CREATE_WEBRTCTRANSPORT` in the enum `Method` - RouterCreateWebrtctransport = 10, + /// The variant of type `FBS.PlainTransport.TupleNotification` in the union `Body` + TupleNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `ROUTER_CREATE_WEBRTCTRANSPORT_WITH_SERVER` in the enum `Method` - RouterCreateWebrtctransportWithServer = 11, + /// The variant of type `FBS.PlainTransport.RtcpTupleNotification` in the union `Body` + RtcpTupleNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `ROUTER_CREATE_PLAINTRANSPORT` in the enum `Method` - RouterCreatePlaintransport = 12, + /// The variant of type `FBS.DirectTransport.RtcpNotification` in the union `Body` + RtcpNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `ROUTER_CREATE_PIPETRANSPORT` in the enum `Method` - RouterCreatePipetransport = 13, + /// The variant of type `FBS.Consumer.ScoreNotification` in the union `Body` + ScoreNotification(::planus::alloc::boxed::Box), - /// The variant `ROUTER_CREATE_DIRECTTRANSPORT` in the enum `Method` - RouterCreateDirecttransport = 14, + /// The variant of type `FBS.Producer.VideoOrientationChangeNotification` in the union `Body` + VideoOrientationChangeNotification( + ::planus::alloc::boxed::Box< + super::producer::VideoOrientationChangeNotification, + >, + ), - /// The variant `ROUTER_CLOSE_TRANSPORT` in the enum `Method` - RouterCloseTransport = 15, + /// The variant of type `FBS.Consumer.LayersChangeNotification` in the union `Body` + LayersChangeNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `ROUTER_CREATE_ACTIVESPEAKEROBSERVER` in the enum `Method` - RouterCreateActivespeakerobserver = 16, + /// The variant of type `FBS.Consumer.RtpNotification` in the union `Body` + RtpNotification(::planus::alloc::boxed::Box), - /// The variant `ROUTER_CREATE_AUDIOLEVELOBSERVER` in the enum `Method` - RouterCreateAudiolevelobserver = 17, + /// The variant of type `FBS.DataConsumer.MessageNotification` in the union `Body` + MessageNotification( + ::planus::alloc::boxed::Box, + ), - /// The variant `ROUTER_CLOSE_RTPOBSERVER` in the enum `Method` - RouterCloseRtpobserver = 18, + /// The variant of type `FBS.DataConsumer.BufferedAmountLowNotification` in the union `Body` + BufferedAmountLowNotification( + ::planus::alloc::boxed::Box< + super::data_consumer::BufferedAmountLowNotification, + >, + ), - /// The variant `TRANSPORT_DUMP` in the enum `Method` - TransportDump = 19, + /// The variant of type `FBS.ActiveSpeakerObserver.DominantSpeakerNotification` in the union `Body` + DominantSpeakerNotification( + ::planus::alloc::boxed::Box< + super::active_speaker_observer::DominantSpeakerNotification, + >, + ), - /// The variant `TRANSPORT_GET_STATS` in the enum `Method` - TransportGetStats = 20, + /// The variant of type `FBS.AudioLevelObserver.VolumesNotification` in the union `Body` + VolumesNotification( + ::planus::alloc::boxed::Box, + ), + } - /// The variant `TRANSPORT_CONNECT` in the enum `Method` - TransportConnect = 21, + impl Body { + /// Creates a [BodyBuilder] for serializing an instance of this table. + #[inline] + pub fn builder() -> BodyBuilder<::planus::Uninitialized> { + BodyBuilder(::planus::Uninitialized) + } - /// The variant `TRANSPORT_SET_MAX_INCOMING_BITRATE` in the enum `Method` - TransportSetMaxIncomingBitrate = 22, + #[inline] + pub fn create_send_rtcp_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_SET_MAX_OUTGOING_BITRATE` in the enum `Method` - TransportSetMaxOutgoingBitrate = 23, + #[inline] + pub fn create_sctp_state_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_SET_MIN_OUTGOING_BITRATE` in the enum `Method` - TransportSetMinOutgoingBitrate = 24, + #[inline] + pub fn create_send_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_RESTART_ICE` in the enum `Method` - TransportRestartIce = 25, + #[inline] + pub fn create_trace_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_PRODUCE` in the enum `Method` - TransportProduce = 26, + #[inline] + pub fn create_ice_selected_tuple_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::web_rtc_transport::IceSelectedTupleChangeNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_PRODUCE_DATA` in the enum `Method` - TransportProduceData = 27, + #[inline] + pub fn create_ice_state_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::web_rtc_transport::IceStateChangeNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CONSUME` in the enum `Method` - TransportConsume = 28, + #[inline] + pub fn create_dtls_state_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::web_rtc_transport::DtlsStateChangeNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CONSUME_DATA` in the enum `Method` - TransportConsumeData = 29, + #[inline] + pub fn create_tuple_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_ENABLE_TRACE_EVENT` in the enum `Method` - TransportEnableTraceEvent = 30, + #[inline] + pub fn create_rtcp_tuple_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CLOSE_PRODUCER` in the enum `Method` - TransportCloseProducer = 31, + #[inline] + pub fn create_rtcp_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CLOSE_CONSUMER` in the enum `Method` - TransportCloseConsumer = 32, + #[inline] + pub fn create_score_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CLOSE_DATAPRODUCER` in the enum `Method` - TransportCloseDataproducer = 33, + #[inline] + pub fn create_video_orientation_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::producer::VideoOrientationChangeNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) + } - /// The variant `TRANSPORT_CLOSE_DATACONSUMER` in the enum `Method` - TransportCloseDataconsumer = 34, + #[inline] + pub fn create_layers_change_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) + } - /// The variant `PLAINTRANSPORT_CONNECT` in the enum `Method` - PlaintransportConnect = 35, + #[inline] + pub fn create_rtp_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) + } - /// The variant `PIPETRANSPORT_CONNECT` in the enum `Method` - PipetransportConnect = 36, + #[inline] + pub fn create_message_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) + } - /// The variant `WEBRTCTRANSPORT_CONNECT` in the enum `Method` - WebrtctransportConnect = 37, + #[inline] + pub fn create_buffered_amount_low_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::data_consumer::BufferedAmountLowNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) + } - /// The variant `PRODUCER_DUMP` in the enum `Method` - ProducerDump = 38, + #[inline] + pub fn create_dominant_speaker_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::active_speaker_observer::DominantSpeakerNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) + } - /// The variant `PRODUCER_GET_STATS` in the enum `Method` - ProducerGetStats = 39, + #[inline] + pub fn create_volumes_notification( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::audio_level_observer::VolumesNotification, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) + } + } - /// The variant `PRODUCER_PAUSE` in the enum `Method` - ProducerPause = 40, + impl ::planus::WriteAsUnion for Body { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + match self { + Self::SendRtcpNotification(value) => { + Self::create_send_rtcp_notification(builder, value) + } + Self::SctpStateChangeNotification(value) => { + Self::create_sctp_state_change_notification(builder, value) + } + Self::SendNotification(value) => { + Self::create_send_notification(builder, value) + } + Self::TraceNotification(value) => { + Self::create_trace_notification(builder, value) + } + Self::IceSelectedTupleChangeNotification(value) => { + Self::create_ice_selected_tuple_change_notification(builder, value) + } + Self::IceStateChangeNotification(value) => { + Self::create_ice_state_change_notification(builder, value) + } + Self::DtlsStateChangeNotification(value) => { + Self::create_dtls_state_change_notification(builder, value) + } + Self::TupleNotification(value) => { + Self::create_tuple_notification(builder, value) + } + Self::RtcpTupleNotification(value) => { + Self::create_rtcp_tuple_notification(builder, value) + } + Self::RtcpNotification(value) => { + Self::create_rtcp_notification(builder, value) + } + Self::ScoreNotification(value) => { + Self::create_score_notification(builder, value) + } + Self::VideoOrientationChangeNotification(value) => { + Self::create_video_orientation_change_notification(builder, value) + } + Self::LayersChangeNotification(value) => { + Self::create_layers_change_notification(builder, value) + } + Self::RtpNotification(value) => { + Self::create_rtp_notification(builder, value) + } + Self::MessageNotification(value) => { + Self::create_message_notification(builder, value) + } + Self::BufferedAmountLowNotification(value) => { + Self::create_buffered_amount_low_notification(builder, value) + } + Self::DominantSpeakerNotification(value) => { + Self::create_dominant_speaker_notification(builder, value) + } + Self::VolumesNotification(value) => { + Self::create_volumes_notification(builder, value) + } + } + } + } - /// The variant `PRODUCER_RESUME` in the enum `Method` - ProducerResume = 41, + impl ::planus::WriteAsOptionalUnion for Body { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } - /// The variant `PRODUCER_ENABLE_TRACE_EVENT` in the enum `Method` - ProducerEnableTraceEvent = 42, + /// Builder for serializing an instance of the [Body] type. + /// + /// Can be created using the [Body::builder] method. + #[derive(Debug)] + #[must_use] + pub struct BodyBuilder(T); - /// The variant `CONSUMER_DUMP` in the enum `Method` - ConsumerDump = 43, - - /// The variant `CONSUMER_GET_STATS` in the enum `Method` - ConsumerGetStats = 44, - - /// The variant `CONSUMER_PAUSE` in the enum `Method` - ConsumerPause = 45, - - /// The variant `CONSUMER_RESUME` in the enum `Method` - ConsumerResume = 46, - - /// The variant `CONSUMER_SET_PREFERRED_LAYERS` in the enum `Method` - ConsumerSetPreferredLayers = 47, - - /// The variant `CONSUMER_SET_PRIORITY` in the enum `Method` - ConsumerSetPriority = 48, - - /// The variant `CONSUMER_REQUEST_KEY_FRAME` in the enum `Method` - ConsumerRequestKeyFrame = 49, - - /// The variant `CONSUMER_ENABLE_TRACE_EVENT` in the enum `Method` - ConsumerEnableTraceEvent = 50, - - /// The variant `DATAPRODUCER_DUMP` in the enum `Method` - DataproducerDump = 51, - - /// The variant `DATAPRODUCER_GET_STATS` in the enum `Method` - DataproducerGetStats = 52, - - /// The variant `DATAPRODUCER_PAUSE` in the enum `Method` - DataproducerPause = 53, - - /// The variant `DATAPRODUCER_RESUME` in the enum `Method` - DataproducerResume = 54, + impl BodyBuilder<::planus::Uninitialized> { + /// Creates an instance of the [`SendRtcpNotification` variant](Body#variant.SendRtcpNotification). + #[inline] + pub fn send_rtcp_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_DUMP` in the enum `Method` - DataconsumerDump = 55, + /// Creates an instance of the [`SctpStateChangeNotification` variant](Body#variant.SctpStateChangeNotification). + #[inline] + pub fn sctp_state_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_GET_STATS` in the enum `Method` - DataconsumerGetStats = 56, + /// Creates an instance of the [`SendNotification` variant](Body#variant.SendNotification). + #[inline] + pub fn send_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_PAUSE` in the enum `Method` - DataconsumerPause = 57, + /// Creates an instance of the [`TraceNotification` variant](Body#variant.TraceNotification). + #[inline] + pub fn trace_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_RESUME` in the enum `Method` - DataconsumerResume = 58, + /// Creates an instance of the [`IceSelectedTupleChangeNotification` variant](Body#variant.IceSelectedTupleChangeNotification). + #[inline] + pub fn ice_selected_tuple_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset< + super::web_rtc_transport::IceSelectedTupleChangeNotification, + >, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_GET_BUFFERED_AMOUNT` in the enum `Method` - DataconsumerGetBufferedAmount = 59, + /// Creates an instance of the [`IceStateChangeNotification` variant](Body#variant.IceStateChangeNotification). + #[inline] + pub fn ice_state_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset< + super::web_rtc_transport::IceStateChangeNotification, + >, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_SET_BUFFERED_AMOUNT_LOW_THRESHOLD` in the enum `Method` - DataconsumerSetBufferedAmountLowThreshold = 60, + /// Creates an instance of the [`DtlsStateChangeNotification` variant](Body#variant.DtlsStateChangeNotification). + #[inline] + pub fn dtls_state_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset< + super::web_rtc_transport::DtlsStateChangeNotification, + >, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_SEND` in the enum `Method` - DataconsumerSend = 61, + /// Creates an instance of the [`TupleNotification` variant](Body#variant.TupleNotification). + #[inline] + pub fn tuple_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `DATACONSUMER_SET_SUBCHANNELS` in the enum `Method` - DataconsumerSetSubchannels = 62, + /// Creates an instance of the [`RtcpTupleNotification` variant](Body#variant.RtcpTupleNotification). + #[inline] + pub fn rtcp_tuple_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `RTPOBSERVER_PAUSE` in the enum `Method` - RtpobserverPause = 63, + /// Creates an instance of the [`RtcpNotification` variant](Body#variant.RtcpNotification). + #[inline] + pub fn rtcp_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `RTPOBSERVER_RESUME` in the enum `Method` - RtpobserverResume = 64, + /// Creates an instance of the [`ScoreNotification` variant](Body#variant.ScoreNotification). + #[inline] + pub fn score_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `RTPOBSERVER_ADD_PRODUCER` in the enum `Method` - RtpobserverAddProducer = 65, + /// Creates an instance of the [`VideoOrientationChangeNotification` variant](Body#variant.VideoOrientationChangeNotification). + #[inline] + pub fn video_orientation_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - /// The variant `RTPOBSERVER_REMOVE_PRODUCER` in the enum `Method` - RtpobserverRemoveProducer = 66, - } + /// Creates an instance of the [`LayersChangeNotification` variant](Body#variant.LayersChangeNotification). + #[inline] + pub fn layers_change_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - impl Method { - /// Array containing all valid variants of Method - pub const ENUM_VALUES: [Self; 67] = [ - Self::WorkerClose, - Self::WorkerDump, - Self::WorkerGetResourceUsage, - Self::WorkerUpdateSettings, - Self::WorkerCreateWebrtcserver, - Self::WorkerCreateRouter, - Self::WorkerWebrtcserverClose, - Self::WorkerCloseRouter, - Self::WebrtcserverDump, - Self::RouterDump, - Self::RouterCreateWebrtctransport, - Self::RouterCreateWebrtctransportWithServer, - Self::RouterCreatePlaintransport, - Self::RouterCreatePipetransport, - Self::RouterCreateDirecttransport, - Self::RouterCloseTransport, - Self::RouterCreateActivespeakerobserver, - Self::RouterCreateAudiolevelobserver, - Self::RouterCloseRtpobserver, - Self::TransportDump, - Self::TransportGetStats, - Self::TransportConnect, - Self::TransportSetMaxIncomingBitrate, - Self::TransportSetMaxOutgoingBitrate, - Self::TransportSetMinOutgoingBitrate, - Self::TransportRestartIce, - Self::TransportProduce, - Self::TransportProduceData, - Self::TransportConsume, - Self::TransportConsumeData, - Self::TransportEnableTraceEvent, - Self::TransportCloseProducer, - Self::TransportCloseConsumer, - Self::TransportCloseDataproducer, - Self::TransportCloseDataconsumer, - Self::PlaintransportConnect, - Self::PipetransportConnect, - Self::WebrtctransportConnect, - Self::ProducerDump, - Self::ProducerGetStats, - Self::ProducerPause, - Self::ProducerResume, - Self::ProducerEnableTraceEvent, - Self::ConsumerDump, - Self::ConsumerGetStats, - Self::ConsumerPause, - Self::ConsumerResume, - Self::ConsumerSetPreferredLayers, - Self::ConsumerSetPriority, - Self::ConsumerRequestKeyFrame, - Self::ConsumerEnableTraceEvent, - Self::DataproducerDump, - Self::DataproducerGetStats, - Self::DataproducerPause, - Self::DataproducerResume, - Self::DataconsumerDump, - Self::DataconsumerGetStats, - Self::DataconsumerPause, - Self::DataconsumerResume, - Self::DataconsumerGetBufferedAmount, - Self::DataconsumerSetBufferedAmountLowThreshold, - Self::DataconsumerSend, - Self::DataconsumerSetSubchannels, - Self::RtpobserverPause, - Self::RtpobserverResume, - Self::RtpobserverAddProducer, - Self::RtpobserverRemoveProducer, - ]; - } + /// Creates an instance of the [`RtpNotification` variant](Body#variant.RtpNotification). + #[inline] + pub fn rtp_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - impl ::core::convert::TryFrom for Method { - type Error = ::planus::errors::UnknownEnumTagKind; + /// Creates an instance of the [`MessageNotification` variant](Body#variant.MessageNotification). #[inline] - fn try_from( - value: u8, - ) -> ::core::result::Result + pub fn message_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, { - #[allow(clippy::match_single_binding)] - match value { - 0 => ::core::result::Result::Ok(Method::WorkerClose), - 1 => ::core::result::Result::Ok(Method::WorkerDump), - 2 => ::core::result::Result::Ok(Method::WorkerGetResourceUsage), - 3 => ::core::result::Result::Ok(Method::WorkerUpdateSettings), - 4 => ::core::result::Result::Ok(Method::WorkerCreateWebrtcserver), - 5 => ::core::result::Result::Ok(Method::WorkerCreateRouter), - 6 => ::core::result::Result::Ok(Method::WorkerWebrtcserverClose), - 7 => ::core::result::Result::Ok(Method::WorkerCloseRouter), - 8 => ::core::result::Result::Ok(Method::WebrtcserverDump), - 9 => ::core::result::Result::Ok(Method::RouterDump), - 10 => ::core::result::Result::Ok(Method::RouterCreateWebrtctransport), - 11 => ::core::result::Result::Ok( - Method::RouterCreateWebrtctransportWithServer, - ), - 12 => ::core::result::Result::Ok(Method::RouterCreatePlaintransport), - 13 => ::core::result::Result::Ok(Method::RouterCreatePipetransport), - 14 => ::core::result::Result::Ok(Method::RouterCreateDirecttransport), - 15 => ::core::result::Result::Ok(Method::RouterCloseTransport), - 16 => ::core::result::Result::Ok(Method::RouterCreateActivespeakerobserver), - 17 => ::core::result::Result::Ok(Method::RouterCreateAudiolevelobserver), - 18 => ::core::result::Result::Ok(Method::RouterCloseRtpobserver), - 19 => ::core::result::Result::Ok(Method::TransportDump), - 20 => ::core::result::Result::Ok(Method::TransportGetStats), - 21 => ::core::result::Result::Ok(Method::TransportConnect), - 22 => ::core::result::Result::Ok(Method::TransportSetMaxIncomingBitrate), - 23 => ::core::result::Result::Ok(Method::TransportSetMaxOutgoingBitrate), - 24 => ::core::result::Result::Ok(Method::TransportSetMinOutgoingBitrate), - 25 => ::core::result::Result::Ok(Method::TransportRestartIce), - 26 => ::core::result::Result::Ok(Method::TransportProduce), - 27 => ::core::result::Result::Ok(Method::TransportProduceData), - 28 => ::core::result::Result::Ok(Method::TransportConsume), - 29 => ::core::result::Result::Ok(Method::TransportConsumeData), - 30 => ::core::result::Result::Ok(Method::TransportEnableTraceEvent), - 31 => ::core::result::Result::Ok(Method::TransportCloseProducer), - 32 => ::core::result::Result::Ok(Method::TransportCloseConsumer), - 33 => ::core::result::Result::Ok(Method::TransportCloseDataproducer), - 34 => ::core::result::Result::Ok(Method::TransportCloseDataconsumer), - 35 => ::core::result::Result::Ok(Method::PlaintransportConnect), - 36 => ::core::result::Result::Ok(Method::PipetransportConnect), - 37 => ::core::result::Result::Ok(Method::WebrtctransportConnect), - 38 => ::core::result::Result::Ok(Method::ProducerDump), - 39 => ::core::result::Result::Ok(Method::ProducerGetStats), - 40 => ::core::result::Result::Ok(Method::ProducerPause), - 41 => ::core::result::Result::Ok(Method::ProducerResume), - 42 => ::core::result::Result::Ok(Method::ProducerEnableTraceEvent), - 43 => ::core::result::Result::Ok(Method::ConsumerDump), - 44 => ::core::result::Result::Ok(Method::ConsumerGetStats), - 45 => ::core::result::Result::Ok(Method::ConsumerPause), - 46 => ::core::result::Result::Ok(Method::ConsumerResume), - 47 => ::core::result::Result::Ok(Method::ConsumerSetPreferredLayers), - 48 => ::core::result::Result::Ok(Method::ConsumerSetPriority), - 49 => ::core::result::Result::Ok(Method::ConsumerRequestKeyFrame), - 50 => ::core::result::Result::Ok(Method::ConsumerEnableTraceEvent), - 51 => ::core::result::Result::Ok(Method::DataproducerDump), - 52 => ::core::result::Result::Ok(Method::DataproducerGetStats), - 53 => ::core::result::Result::Ok(Method::DataproducerPause), - 54 => ::core::result::Result::Ok(Method::DataproducerResume), - 55 => ::core::result::Result::Ok(Method::DataconsumerDump), - 56 => ::core::result::Result::Ok(Method::DataconsumerGetStats), - 57 => ::core::result::Result::Ok(Method::DataconsumerPause), - 58 => ::core::result::Result::Ok(Method::DataconsumerResume), - 59 => ::core::result::Result::Ok(Method::DataconsumerGetBufferedAmount), - 60 => ::core::result::Result::Ok( - Method::DataconsumerSetBufferedAmountLowThreshold, - ), - 61 => ::core::result::Result::Ok(Method::DataconsumerSend), - 62 => ::core::result::Result::Ok(Method::DataconsumerSetSubchannels), - 63 => ::core::result::Result::Ok(Method::RtpobserverPause), - 64 => ::core::result::Result::Ok(Method::RtpobserverResume), - 65 => ::core::result::Result::Ok(Method::RtpobserverAddProducer), - 66 => ::core::result::Result::Ok(Method::RtpobserverRemoveProducer), + BodyBuilder(::planus::Initialized(value)) + } - _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { - tag: value as i128, - }), - } + /// Creates an instance of the [`BufferedAmountLowNotification` variant](Body#variant.BufferedAmountLowNotification). + #[inline] + pub fn buffered_amount_low_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::core::convert::From for u8 { + /// Creates an instance of the [`DominantSpeakerNotification` variant](Body#variant.DominantSpeakerNotification). #[inline] - fn from(value: Method) -> Self { - value as u8 + pub fn dominant_speaker_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset< + super::active_speaker_observer::DominantSpeakerNotification, + >, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::Primitive for Method { - const ALIGNMENT: usize = 1; - const SIZE: usize = 1; + /// Creates an instance of the [`VolumesNotification` variant](Body#variant.VolumesNotification). + #[inline] + pub fn volumes_notification( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } } - impl ::planus::WriteAsPrimitive for Method { + impl BodyBuilder<::planus::Initialized> { + /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. #[inline] - fn write( - &self, - cursor: ::planus::Cursor<'_, N>, - buffer_position: u32, - ) { - (*self as u8).write(cursor, buffer_position); + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset + where + Self: ::planus::WriteAsUnion, + { + ::planus::WriteAsUnion::prepare(&self, builder) } } - impl ::planus::WriteAs for Method { - type Prepared = Self; - + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Method { - *self + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsDefault for Method { - type Prepared = Self; - + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] fn prepare( &self, - _builder: &mut ::planus::Builder, - default: &Method, - ) -> ::core::option::Option { - if self == default { - ::core::option::Option::None - } else { - ::core::option::Option::Some(*self) - } + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptional for Method { - type Prepared = Self; - + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] fn prepare( &self, - _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { - ::core::option::Option::Some(*self) + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl<'buf> ::planus::TableRead<'buf> for Method { + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result { - let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; - ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) } } - impl<'buf> ::planus::VectorReadInner<'buf> for Method { - type Error = ::planus::errors::UnknownEnumTag; - const STRIDE: usize = 1; + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result - { - let value = *buffer.buffer.get_unchecked(offset); - let value: ::core::result::Result = - ::core::convert::TryInto::try_into(value); - value.map_err(|error_kind| { - error_kind.with_error_location( - "Method", - "VectorRead::from_buffer", - buffer.offset_from_start, - ) - }) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl ::planus::VectorWrite for Method { - const STRIDE: usize = 1; - - type Value = Self; - + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { - *self + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - unsafe fn write_values( - values: &[Self], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - i as u32, - ); - } + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - /// The union `Body` in the namespace `FBS.Request` - /// - /// Generated from these locations: - /// * Union `Body` in the file `../worker/fbs/request.fbs:81` - #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, - )] - pub enum Body { - /// The variant of type `FBS.Worker.UpdateSettingsRequest` in the union `Body` - UpdateSettingsRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Worker.CreateWebRtcServerRequest` in the union `Body` - CreateWebRtcServerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Worker.CloseWebRtcServerRequest` in the union `Body` - CloseWebRtcServerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Worker.CreateRouterRequest` in the union `Body` - CreateRouterRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Worker.CloseRouterRequest` in the union `Body` - CloseRouterRequest(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Router.CreateWebRtcTransportRequest` in the union `Body` - CreateWebRtcTransportRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CreatePlainTransportRequest` in the union `Body` - CreatePlainTransportRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CreatePipeTransportRequest` in the union `Body` - CreatePipeTransportRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CreateDirectTransportRequest` in the union `Body` - CreateDirectTransportRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CreateActiveSpeakerObserverRequest` in the union `Body` - CreateActiveSpeakerObserverRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CreateAudioLevelObserverRequest` in the union `Body` - CreateAudioLevelObserverRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CloseTransportRequest` in the union `Body` - CloseTransportRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Router.CloseRtpObserverRequest` in the union `Body` - CloseRtpObserverRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.SetMaxIncomingBitrateRequest` in the union `Body` - SetMaxIncomingBitrateRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.SetMaxOutgoingBitrateRequest` in the union `Body` - SetMaxOutgoingBitrateRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.SetMinOutgoingBitrateRequest` in the union `Body` - SetMinOutgoingBitrateRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.ProduceRequest` in the union `Body` - ProduceRequest(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Transport.ConsumeRequest` in the union `Body` - ConsumeRequest(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.Transport.ProduceDataRequest` in the union `Body` - ProduceDataRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.ConsumeDataRequest` in the union `Body` - ConsumeDataRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.EnableTraceEventRequest` in the union `Body` - EnableTraceEventRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.CloseProducerRequest` in the union `Body` - CloseProducerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.CloseConsumerRequest` in the union `Body` - CloseConsumerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.CloseDataProducerRequest` in the union `Body` - CloseDataProducerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Transport.CloseDataConsumerRequest` in the union `Body` - CloseDataConsumerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant `PlainTransport_ConnectRequest` in the union `Body` - PlainTransportConnectRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant `PipeTransport_ConnectRequest` in the union `Body` - PipeTransportConnectRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.WebRtcTransport.ConnectRequest` in the union `Body` - ConnectRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.SetPreferredLayersRequest` in the union `Body` - SetPreferredLayersRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.Consumer.SetPriorityRequest` in the union `Body` - SetPriorityRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.DataConsumer.SetBufferedAmountLowThresholdRequest` in the union `Body` - SetBufferedAmountLowThresholdRequest( - ::planus::alloc::boxed::Box< - super::data_consumer::SetBufferedAmountLowThresholdRequest, - >, - ), - - /// The variant of type `FBS.DataConsumer.SendRequest` in the union `Body` - SendRequest(::planus::alloc::boxed::Box), - - /// The variant of type `FBS.DataConsumer.SetSubchannelsRequest` in the union `Body` - SetSubchannelsRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.RtpObserver.AddProducerRequest` in the union `Body` - AddProducerRequest( - ::planus::alloc::boxed::Box, - ), - - /// The variant of type `FBS.RtpObserver.RemoveProducerRequest` in the union `Body` - RemoveProducerRequest( - ::planus::alloc::boxed::Box, - ), - } - - impl Body { - /// Creates a [BodyBuilder] for serializing an instance of this table. + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset< + super::web_rtc_transport::IceSelectedTupleChangeNotification, + >, + { #[inline] - pub fn builder() -> BodyBuilder<::planus::Uninitialized> { - BodyBuilder(::planus::Uninitialized) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset< + super::web_rtc_transport::IceSelectedTupleChangeNotification, + >, + { #[inline] - pub fn create_update_settings_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_web_rtc_server_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_web_rtc_server_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_router_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_router_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_web_rtc_transport_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_plain_transport_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_pipe_transport_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_direct_transport_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_active_speaker_observer_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::router::CreateActiveSpeakerObserverRequest, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_create_audio_level_observer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_transport_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_rtp_observer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_set_max_incoming_bitrate_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_set_max_outgoing_bitrate_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_set_min_outgoing_bitrate_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_produce_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_consume_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_produce_data_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(19, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_consume_data_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(20, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_enable_trace_event_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(21, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_producer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(22, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset< + super::active_speaker_observer::DominantSpeakerNotification, + >, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset< + super::active_speaker_observer::DominantSpeakerNotification, + >, + { #[inline] - pub fn create_close_consumer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(23, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_close_data_producer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(24, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + + /// Reference to a deserialized [Body]. + #[derive(Copy, Clone, Debug)] + pub enum BodyRef<'a> { + SendRtcpNotification(super::transport::SendRtcpNotificationRef<'a>), + SctpStateChangeNotification(super::transport::SctpStateChangeNotificationRef<'a>), + SendNotification(super::data_producer::SendNotificationRef<'a>), + TraceNotification(super::consumer::TraceNotificationRef<'a>), + IceSelectedTupleChangeNotification( + super::web_rtc_transport::IceSelectedTupleChangeNotificationRef<'a>, + ), + IceStateChangeNotification( + super::web_rtc_transport::IceStateChangeNotificationRef<'a>, + ), + DtlsStateChangeNotification( + super::web_rtc_transport::DtlsStateChangeNotificationRef<'a>, + ), + TupleNotification(super::plain_transport::TupleNotificationRef<'a>), + RtcpTupleNotification(super::plain_transport::RtcpTupleNotificationRef<'a>), + RtcpNotification(super::direct_transport::RtcpNotificationRef<'a>), + ScoreNotification(super::consumer::ScoreNotificationRef<'a>), + VideoOrientationChangeNotification( + super::producer::VideoOrientationChangeNotificationRef<'a>, + ), + LayersChangeNotification(super::consumer::LayersChangeNotificationRef<'a>), + RtpNotification(super::consumer::RtpNotificationRef<'a>), + MessageNotification(super::data_consumer::MessageNotificationRef<'a>), + BufferedAmountLowNotification( + super::data_consumer::BufferedAmountLowNotificationRef<'a>, + ), + DominantSpeakerNotification( + super::active_speaker_observer::DominantSpeakerNotificationRef<'a>, + ), + VolumesNotification(super::audio_level_observer::VolumesNotificationRef<'a>), + } + + impl<'a> ::core::convert::TryFrom> for Body { + type Error = ::planus::Error; + + fn try_from(value: BodyRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + BodyRef::SendRtcpNotification(value) => { + Self::SendRtcpNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SctpStateChangeNotification(value) => { + Self::SctpStateChangeNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SendNotification(value) => { + Self::SendNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::TraceNotification(value) => { + Self::TraceNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::IceSelectedTupleChangeNotification(value) => { + Self::IceSelectedTupleChangeNotification( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) + } + + BodyRef::IceStateChangeNotification(value) => { + Self::IceStateChangeNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::DtlsStateChangeNotification(value) => { + Self::DtlsStateChangeNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::TupleNotification(value) => { + Self::TupleNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::RtcpTupleNotification(value) => { + Self::RtcpTupleNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::RtcpNotification(value) => { + Self::RtcpNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::ScoreNotification(value) => { + Self::ScoreNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::VideoOrientationChangeNotification(value) => { + Self::VideoOrientationChangeNotification( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) + } + + BodyRef::LayersChangeNotification(value) => { + Self::LayersChangeNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::RtpNotification(value) => { + Self::RtpNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::MessageNotification(value) => { + Self::MessageNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::BufferedAmountLowNotification(value) => { + Self::BufferedAmountLowNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::DominantSpeakerNotification(value) => { + Self::DominantSpeakerNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::VolumesNotification(value) => { + Self::VolumesNotification(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + }) + } + } + + impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + field_offset: usize, + tag: u8, + ) -> ::core::result::Result { + match tag { + 1 => ::core::result::Result::Ok(Self::SendRtcpNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::SctpStateChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 3 => ::core::result::Result::Ok(Self::SendNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 4 => ::core::result::Result::Ok(Self::TraceNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 5 => ::core::result::Result::Ok(Self::IceSelectedTupleChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 6 => ::core::result::Result::Ok(Self::IceStateChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 7 => ::core::result::Result::Ok(Self::DtlsStateChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 8 => ::core::result::Result::Ok(Self::TupleNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 9 => ::core::result::Result::Ok(Self::RtcpTupleNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 10 => ::core::result::Result::Ok(Self::RtcpNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 11 => ::core::result::Result::Ok(Self::ScoreNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 12 => ::core::result::Result::Ok(Self::VideoOrientationChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 13 => ::core::result::Result::Ok(Self::LayersChangeNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 14 => ::core::result::Result::Ok(Self::RtpNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 15 => ::core::result::Result::Ok(Self::MessageNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 16 => ::core::result::Result::Ok(Self::BufferedAmountLowNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 17 => ::core::result::Result::Ok(Self::DominantSpeakerNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 18 => ::core::result::Result::Ok(Self::VolumesNotification( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), + } } + } + + /// The table `Notification` in the namespace `FBS.Notification` + /// + /// Generated from these locations: + /// * Table `Notification` in the file `../worker/fbs/notification.fbs:76` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct Notification { + /// The field `handler_id` in the table `Notification` + pub handler_id: ::planus::alloc::string::String, + /// The field `event` in the table `Notification` + pub event: self::Event, + /// The field `body` in the table `Notification` + pub body: ::core::option::Option, + } + impl Notification { + /// Creates a [NotificationBuilder] for serializing an instance of this table. #[inline] - pub fn create_close_data_consumer_request( + pub fn builder() -> NotificationBuilder<()> { + NotificationBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(25, value.prepare(builder).downcast()) + field_handler_id: impl ::planus::WriteAs<::planus::Offset>, + field_event: impl ::planus::WriteAsDefault, + field_body: impl ::planus::WriteAsOptionalUnion, + ) -> ::planus::Offset { + let prepared_handler_id = field_handler_id.prepare(builder); + let prepared_event = + field_event.prepare(builder, &self::Event::TransportSendRtcp); + let prepared_body = field_body.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<12> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); + if prepared_body.is_some() { + table_writer.write_entry::<::planus::Offset>(3); + } + if prepared_event.is_some() { + table_writer.write_entry::(1); + } + if prepared_body.is_some() { + table_writer.write_entry::(2); + } + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_handler_id); + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 4>(&prepared_body.offset()); + } + if let ::core::option::Option::Some(prepared_event) = prepared_event { + object_writer.write::<_, _, 1>(&prepared_event); + } + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 1>(&prepared_body.tag()); + } + }); + } + builder.current_offset() } + } + + impl ::planus::WriteAs<::planus::Offset> for Notification { + type Prepared = ::planus::Offset; #[inline] - pub fn create_plain_transport_connect_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(26, value.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } + + impl ::planus::WriteAsOptional<::planus::Offset> for Notification { + type Prepared = ::planus::Offset; #[inline] - pub fn create_pipe_transport_connect_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(27, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } + impl ::planus::WriteAsOffset for Notification { #[inline] - pub fn create_connect_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(28, value.prepare(builder).downcast()) + ) -> ::planus::Offset { + Notification::create(builder, &self.handler_id, self.event, &self.body) } + } + /// Builder for serializing an instance of the [Notification] type. + /// + /// Can be created using the [Notification::builder] method. + #[derive(Debug)] + #[must_use] + pub struct NotificationBuilder(State); + + impl NotificationBuilder<()> { + /// Setter for the [`handler_id` field](Notification#structfield.handler_id). #[inline] - pub fn create_set_preferred_layers_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(29, value.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn handler_id(self, value: T0) -> NotificationBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + NotificationBuilder((value,)) } + } + impl NotificationBuilder<(T0,)> { + /// Setter for the [`event` field](Notification#structfield.event). #[inline] - pub fn create_set_priority_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(30, value.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn event(self, value: T1) -> NotificationBuilder<(T0, T1)> + where + T1: ::planus::WriteAsDefault, + { + let (v0,) = self.0; + NotificationBuilder((v0, value)) } + /// Sets the [`event` field](Notification#structfield.event) to the default value. #[inline] - pub fn create_set_buffered_amount_low_threshold_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset< - super::data_consumer::SetBufferedAmountLowThresholdRequest, - >, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(31, value.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn event_as_default(self) -> NotificationBuilder<(T0, ::planus::DefaultValue)> { + self.event(::planus::DefaultValue) } + } + impl NotificationBuilder<(T0, T1)> { + /// Setter for the [`body` field](Notification#structfield.body). #[inline] - pub fn create_send_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(32, value.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn body(self, value: T2) -> NotificationBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsOptionalUnion, + { + let (v0, v1) = self.0; + NotificationBuilder((v0, v1, value)) } + /// Sets the [`body` field](Notification#structfield.body) to null. #[inline] - pub fn create_set_subchannels_request( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(33, value.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn body_as_null(self) -> NotificationBuilder<(T0, T1, ())> { + self.body(()) } + } + impl NotificationBuilder<(T0, T1, T2)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Notification]. #[inline] - pub fn create_add_producer_request( + pub fn finish( + self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(34, value.prepare(builder).downcast()) + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } + } + + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAs<::planus::Offset> + for NotificationBuilder<(T0, T1, T2)> + { + type Prepared = ::planus::Offset; #[inline] - pub fn create_remove_producer_request( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(35, value.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsUnion for Body { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - match self { - Self::UpdateSettingsRequest(value) => { - Self::create_update_settings_request(builder, value) - } - Self::CreateWebRtcServerRequest(value) => { - Self::create_create_web_rtc_server_request(builder, value) - } - Self::CloseWebRtcServerRequest(value) => { - Self::create_close_web_rtc_server_request(builder, value) - } - Self::CreateRouterRequest(value) => { - Self::create_create_router_request(builder, value) - } - Self::CloseRouterRequest(value) => { - Self::create_close_router_request(builder, value) - } - Self::CreateWebRtcTransportRequest(value) => { - Self::create_create_web_rtc_transport_request(builder, value) - } - Self::CreatePlainTransportRequest(value) => { - Self::create_create_plain_transport_request(builder, value) - } - Self::CreatePipeTransportRequest(value) => { - Self::create_create_pipe_transport_request(builder, value) - } - Self::CreateDirectTransportRequest(value) => { - Self::create_create_direct_transport_request(builder, value) - } - Self::CreateActiveSpeakerObserverRequest(value) => { - Self::create_create_active_speaker_observer_request(builder, value) - } - Self::CreateAudioLevelObserverRequest(value) => { - Self::create_create_audio_level_observer_request(builder, value) - } - Self::CloseTransportRequest(value) => { - Self::create_close_transport_request(builder, value) - } - Self::CloseRtpObserverRequest(value) => { - Self::create_close_rtp_observer_request(builder, value) - } - Self::SetMaxIncomingBitrateRequest(value) => { - Self::create_set_max_incoming_bitrate_request(builder, value) - } - Self::SetMaxOutgoingBitrateRequest(value) => { - Self::create_set_max_outgoing_bitrate_request(builder, value) - } - Self::SetMinOutgoingBitrateRequest(value) => { - Self::create_set_min_outgoing_bitrate_request(builder, value) - } - Self::ProduceRequest(value) => Self::create_produce_request(builder, value), - Self::ConsumeRequest(value) => Self::create_consume_request(builder, value), - Self::ProduceDataRequest(value) => { - Self::create_produce_data_request(builder, value) - } - Self::ConsumeDataRequest(value) => { - Self::create_consume_data_request(builder, value) - } - Self::EnableTraceEventRequest(value) => { - Self::create_enable_trace_event_request(builder, value) - } - Self::CloseProducerRequest(value) => { - Self::create_close_producer_request(builder, value) - } - Self::CloseConsumerRequest(value) => { - Self::create_close_consumer_request(builder, value) - } - Self::CloseDataProducerRequest(value) => { - Self::create_close_data_producer_request(builder, value) - } - Self::CloseDataConsumerRequest(value) => { - Self::create_close_data_consumer_request(builder, value) - } - Self::PlainTransportConnectRequest(value) => { - Self::create_plain_transport_connect_request(builder, value) - } - Self::PipeTransportConnectRequest(value) => { - Self::create_pipe_transport_connect_request(builder, value) - } - Self::ConnectRequest(value) => Self::create_connect_request(builder, value), - Self::SetPreferredLayersRequest(value) => { - Self::create_set_preferred_layers_request(builder, value) - } - Self::SetPriorityRequest(value) => { - Self::create_set_priority_request(builder, value) - } - Self::SetBufferedAmountLowThresholdRequest(value) => { - Self::create_set_buffered_amount_low_threshold_request(builder, value) - } - Self::SendRequest(value) => Self::create_send_request(builder, value), - Self::SetSubchannelsRequest(value) => { - Self::create_set_subchannels_request(builder, value) - } - Self::AddProducerRequest(value) => { - Self::create_add_producer_request(builder, value) - } - Self::RemoveProducerRequest(value) => { - Self::create_remove_producer_request(builder, value) - } - } - } - } + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOptional<::planus::Offset> + for NotificationBuilder<(T0, T1, T2)> + { + type Prepared = ::planus::Offset; - impl ::planus::WriteAsOptionalUnion for Body { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - /// Builder for serializing an instance of the [Body] type. - /// - /// Can be created using the [Body::builder] method. - #[derive(Debug)] - #[must_use] - pub struct BodyBuilder(T); - - impl BodyBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`UpdateSettingsRequest` variant](Body#variant.UpdateSettingsRequest). + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOffset for NotificationBuilder<(T0, T1, T2)> + { #[inline] - pub fn update_settings_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0, v1, v2) = &self.0; + Notification::create(builder, v0, v1, v2) } + } - /// Creates an instance of the [`CreateWebRtcServerRequest` variant](Body#variant.CreateWebRtcServerRequest). - #[inline] - pub fn create_web_rtc_server_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// Reference to a deserialized [Notification]. + #[derive(Copy, Clone)] + pub struct NotificationRef<'a>(::planus::table_reader::Table<'a>); - /// Creates an instance of the [`CloseWebRtcServerRequest` variant](Body#variant.CloseWebRtcServerRequest). + impl<'a> NotificationRef<'a> { + /// Getter for the [`handler_id` field](Notification#structfield.handler_id). #[inline] - pub fn close_web_rtc_server_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + pub fn handler_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "Notification", "handler_id") } - /// Creates an instance of the [`CreateRouterRequest` variant](Body#variant.CreateRouterRequest). + /// Getter for the [`event` field](Notification#structfield.event). #[inline] - pub fn create_router_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + pub fn event(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "Notification", "event")? + .unwrap_or(self::Event::TransportSendRtcp), + ) } - /// Creates an instance of the [`CloseRouterRequest` variant](Body#variant.CloseRouterRequest). + /// Getter for the [`body` field](Notification#structfield.body). #[inline] - pub fn close_router_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + pub fn body(&self) -> ::planus::Result<::core::option::Option>> { + self.0.access_union(2, "Notification", "body") } + } - /// Creates an instance of the [`CreateWebRtcTransportRequest` variant](Body#variant.CreateWebRtcTransportRequest). - #[inline] - pub fn create_web_rtc_transport_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + impl<'a> ::core::fmt::Debug for NotificationRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("NotificationRef"); + f.field("handler_id", &self.handler_id()); + f.field("event", &self.event()); + if let ::core::option::Option::Some(field_body) = self.body().transpose() { + f.field("body", &field_body); + } + f.finish() } + } - /// Creates an instance of the [`CreatePlainTransportRequest` variant](Body#variant.CreatePlainTransportRequest). - #[inline] - pub fn create_plain_transport_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + impl<'a> ::core::convert::TryFrom> for Notification { + type Error = ::planus::Error; - /// Creates an instance of the [`CreatePipeTransportRequest` variant](Body#variant.CreatePipeTransportRequest). - #[inline] - pub fn create_pipe_transport_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(unreachable_code)] + fn try_from(value: NotificationRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + handler_id: ::core::convert::TryInto::try_into(value.handler_id()?)?, + event: ::core::convert::TryInto::try_into(value.event()?)?, + body: if let ::core::option::Option::Some(body) = value.body()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) + } else { + ::core::option::Option::None + }, + }) } + } - /// Creates an instance of the [`CreateDirectTransportRequest` variant](Body#variant.CreateDirectTransportRequest). + impl<'a> ::planus::TableRead<'a> for NotificationRef<'a> { #[inline] - pub fn create_direct_transport_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } + } - /// Creates an instance of the [`CreateActiveSpeakerObserverRequest` variant](Body#variant.CreateActiveSpeakerObserverRequest). - #[inline] - pub fn create_active_speaker_observer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + impl<'a> ::planus::VectorReadInner<'a> for NotificationRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; - /// Creates an instance of the [`CreateAudioLevelObserverRequest` variant](Body#variant.CreateAudioLevelObserverRequest). - #[inline] - pub fn create_audio_level_observer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[NotificationRef]", + "get", + buffer.offset_from_start, + ) + }) } + } - /// Creates an instance of the [`CloseTransportRequest` variant](Body#variant.CloseTransportRequest). + impl ::planus::VectorWrite<::planus::Offset> for Notification { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - pub fn close_transport_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - /// Creates an instance of the [`CloseRtpObserverRequest` variant](Body#variant.CloseRtpObserverRequest). #[inline] - pub fn close_rtp_observer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } + } - /// Creates an instance of the [`SetMaxIncomingBitrateRequest` variant](Body#variant.SetMaxIncomingBitrateRequest). - #[inline] - pub fn set_max_incoming_bitrate_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + impl<'a> ::planus::ReadAsRoot<'a> for NotificationRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[NotificationRef]", "read_as_root", 0) + }) } + } + } + /// The namespace `FBS.Request` + /// + /// Generated from these locations: + /// * File `../worker/fbs/request.fbs` + pub mod request { + /// The enum `Method` in the namespace `FBS.Request` + /// + /// Generated from these locations: + /// * Enum `Method` in the file `../worker/fbs/request.fbs:11` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum Method { + /// The variant `WORKER_CLOSE` in the enum `Method` + WorkerClose = 0, - /// Creates an instance of the [`SetMaxOutgoingBitrateRequest` variant](Body#variant.SetMaxOutgoingBitrateRequest). - #[inline] - pub fn set_max_outgoing_bitrate_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_DUMP` in the enum `Method` + WorkerDump = 1, - /// Creates an instance of the [`SetMinOutgoingBitrateRequest` variant](Body#variant.SetMinOutgoingBitrateRequest). - #[inline] - pub fn set_min_outgoing_bitrate_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_GET_RESOURCE_USAGE` in the enum `Method` + WorkerGetResourceUsage = 2, - /// Creates an instance of the [`ProduceRequest` variant](Body#variant.ProduceRequest). - #[inline] - pub fn produce_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_UPDATE_SETTINGS` in the enum `Method` + WorkerUpdateSettings = 3, - /// Creates an instance of the [`ConsumeRequest` variant](Body#variant.ConsumeRequest). - #[inline] - pub fn consume_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_CREATE_WEBRTCSERVER` in the enum `Method` + WorkerCreateWebrtcserver = 4, - /// Creates an instance of the [`ProduceDataRequest` variant](Body#variant.ProduceDataRequest). - #[inline] - pub fn produce_data_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_CREATE_ROUTER` in the enum `Method` + WorkerCreateRouter = 5, - /// Creates an instance of the [`ConsumeDataRequest` variant](Body#variant.ConsumeDataRequest). - #[inline] - pub fn consume_data_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_WEBRTCSERVER_CLOSE` in the enum `Method` + WorkerWebrtcserverClose = 6, - /// Creates an instance of the [`EnableTraceEventRequest` variant](Body#variant.EnableTraceEventRequest). - #[inline] - pub fn enable_trace_event_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<21, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WORKER_CLOSE_ROUTER` in the enum `Method` + WorkerCloseRouter = 7, - /// Creates an instance of the [`CloseProducerRequest` variant](Body#variant.CloseProducerRequest). - #[inline] - pub fn close_producer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `WEBRTCSERVER_DUMP` in the enum `Method` + WebrtcserverDump = 8, - /// Creates an instance of the [`CloseConsumerRequest` variant](Body#variant.CloseConsumerRequest). - #[inline] - pub fn close_consumer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<23, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_DUMP` in the enum `Method` + RouterDump = 9, - /// Creates an instance of the [`CloseDataProducerRequest` variant](Body#variant.CloseDataProducerRequest). - #[inline] - pub fn close_data_producer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_WEBRTCTRANSPORT` in the enum `Method` + RouterCreateWebrtctransport = 10, - /// Creates an instance of the [`CloseDataConsumerRequest` variant](Body#variant.CloseDataConsumerRequest). - #[inline] - pub fn close_data_consumer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<25, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_WEBRTCTRANSPORT_WITH_SERVER` in the enum `Method` + RouterCreateWebrtctransportWithServer = 11, - /// Creates an instance of the [`PlainTransport_ConnectRequest` variant](Body#variant.PlainTransportConnectRequest). - #[inline] - pub fn plain_transport_connect_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_PLAINTRANSPORT` in the enum `Method` + RouterCreatePlaintransport = 12, - /// Creates an instance of the [`PipeTransport_ConnectRequest` variant](Body#variant.PipeTransportConnectRequest). - #[inline] - pub fn pipe_transport_connect_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<27, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_PIPETRANSPORT` in the enum `Method` + RouterCreatePipetransport = 13, - /// Creates an instance of the [`ConnectRequest` variant](Body#variant.ConnectRequest). - #[inline] - pub fn connect_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_DIRECTTRANSPORT` in the enum `Method` + RouterCreateDirecttransport = 14, - /// Creates an instance of the [`SetPreferredLayersRequest` variant](Body#variant.SetPreferredLayersRequest). - #[inline] - pub fn set_preferred_layers_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<29, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CLOSE_TRANSPORT` in the enum `Method` + RouterCloseTransport = 15, - /// Creates an instance of the [`SetPriorityRequest` variant](Body#variant.SetPriorityRequest). - #[inline] - pub fn set_priority_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<30, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_ACTIVESPEAKEROBSERVER` in the enum `Method` + RouterCreateActivespeakerobserver = 16, - /// Creates an instance of the [`SetBufferedAmountLowThresholdRequest` variant](Body#variant.SetBufferedAmountLowThresholdRequest). - #[inline] - pub fn set_buffered_amount_low_threshold_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<31, T>> - where - T: ::planus::WriteAsOffset< - super::data_consumer::SetBufferedAmountLowThresholdRequest, - >, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CREATE_AUDIOLEVELOBSERVER` in the enum `Method` + RouterCreateAudiolevelobserver = 17, - /// Creates an instance of the [`SendRequest` variant](Body#variant.SendRequest). - #[inline] - pub fn send_request(self, value: T) -> BodyBuilder<::planus::Initialized<32, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `ROUTER_CLOSE_RTPOBSERVER` in the enum `Method` + RouterCloseRtpobserver = 18, - /// Creates an instance of the [`SetSubchannelsRequest` variant](Body#variant.SetSubchannelsRequest). - #[inline] - pub fn set_subchannels_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<33, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `TRANSPORT_DUMP` in the enum `Method` + TransportDump = 19, - /// Creates an instance of the [`AddProducerRequest` variant](Body#variant.AddProducerRequest). - #[inline] - pub fn add_producer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<34, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `TRANSPORT_GET_STATS` in the enum `Method` + TransportGetStats = 20, - /// Creates an instance of the [`RemoveProducerRequest` variant](Body#variant.RemoveProducerRequest). - #[inline] - pub fn remove_producer_request( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<35, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// The variant `TRANSPORT_CONNECT` in the enum `Method` + TransportConnect = 21, + + /// The variant `TRANSPORT_SET_MAX_INCOMING_BITRATE` in the enum `Method` + TransportSetMaxIncomingBitrate = 22, + + /// The variant `TRANSPORT_SET_MAX_OUTGOING_BITRATE` in the enum `Method` + TransportSetMaxOutgoingBitrate = 23, + + /// The variant `TRANSPORT_SET_MIN_OUTGOING_BITRATE` in the enum `Method` + TransportSetMinOutgoingBitrate = 24, + + /// The variant `TRANSPORT_RESTART_ICE` in the enum `Method` + TransportRestartIce = 25, + + /// The variant `TRANSPORT_PRODUCE` in the enum `Method` + TransportProduce = 26, + + /// The variant `TRANSPORT_PRODUCE_DATA` in the enum `Method` + TransportProduceData = 27, + + /// The variant `TRANSPORT_CONSUME` in the enum `Method` + TransportConsume = 28, + + /// The variant `TRANSPORT_CONSUME_DATA` in the enum `Method` + TransportConsumeData = 29, + + /// The variant `TRANSPORT_ENABLE_TRACE_EVENT` in the enum `Method` + TransportEnableTraceEvent = 30, + + /// The variant `TRANSPORT_CLOSE_PRODUCER` in the enum `Method` + TransportCloseProducer = 31, + + /// The variant `TRANSPORT_CLOSE_CONSUMER` in the enum `Method` + TransportCloseConsumer = 32, + + /// The variant `TRANSPORT_CLOSE_DATAPRODUCER` in the enum `Method` + TransportCloseDataproducer = 33, + + /// The variant `TRANSPORT_CLOSE_DATACONSUMER` in the enum `Method` + TransportCloseDataconsumer = 34, + + /// The variant `PLAINTRANSPORT_CONNECT` in the enum `Method` + PlaintransportConnect = 35, + + /// The variant `PIPETRANSPORT_CONNECT` in the enum `Method` + PipetransportConnect = 36, + + /// The variant `WEBRTCTRANSPORT_CONNECT` in the enum `Method` + WebrtctransportConnect = 37, + + /// The variant `PRODUCER_DUMP` in the enum `Method` + ProducerDump = 38, + + /// The variant `PRODUCER_GET_STATS` in the enum `Method` + ProducerGetStats = 39, + + /// The variant `PRODUCER_PAUSE` in the enum `Method` + ProducerPause = 40, + + /// The variant `PRODUCER_RESUME` in the enum `Method` + ProducerResume = 41, + + /// The variant `PRODUCER_ENABLE_TRACE_EVENT` in the enum `Method` + ProducerEnableTraceEvent = 42, + + /// The variant `CONSUMER_DUMP` in the enum `Method` + ConsumerDump = 43, + + /// The variant `CONSUMER_GET_STATS` in the enum `Method` + ConsumerGetStats = 44, + + /// The variant `CONSUMER_PAUSE` in the enum `Method` + ConsumerPause = 45, + + /// The variant `CONSUMER_RESUME` in the enum `Method` + ConsumerResume = 46, + + /// The variant `CONSUMER_SET_PREFERRED_LAYERS` in the enum `Method` + ConsumerSetPreferredLayers = 47, + + /// The variant `CONSUMER_SET_PRIORITY` in the enum `Method` + ConsumerSetPriority = 48, + + /// The variant `CONSUMER_REQUEST_KEY_FRAME` in the enum `Method` + ConsumerRequestKeyFrame = 49, + + /// The variant `CONSUMER_ENABLE_TRACE_EVENT` in the enum `Method` + ConsumerEnableTraceEvent = 50, + + /// The variant `DATAPRODUCER_DUMP` in the enum `Method` + DataproducerDump = 51, + + /// The variant `DATAPRODUCER_GET_STATS` in the enum `Method` + DataproducerGetStats = 52, + + /// The variant `DATAPRODUCER_PAUSE` in the enum `Method` + DataproducerPause = 53, + + /// The variant `DATAPRODUCER_RESUME` in the enum `Method` + DataproducerResume = 54, + + /// The variant `DATACONSUMER_DUMP` in the enum `Method` + DataconsumerDump = 55, + + /// The variant `DATACONSUMER_GET_STATS` in the enum `Method` + DataconsumerGetStats = 56, + + /// The variant `DATACONSUMER_PAUSE` in the enum `Method` + DataconsumerPause = 57, + + /// The variant `DATACONSUMER_RESUME` in the enum `Method` + DataconsumerResume = 58, + + /// The variant `DATACONSUMER_GET_BUFFERED_AMOUNT` in the enum `Method` + DataconsumerGetBufferedAmount = 59, + + /// The variant `DATACONSUMER_SET_BUFFERED_AMOUNT_LOW_THRESHOLD` in the enum `Method` + DataconsumerSetBufferedAmountLowThreshold = 60, + + /// The variant `DATACONSUMER_SEND` in the enum `Method` + DataconsumerSend = 61, + + /// The variant `DATACONSUMER_SET_SUBCHANNELS` in the enum `Method` + DataconsumerSetSubchannels = 62, + + /// The variant `RTPOBSERVER_PAUSE` in the enum `Method` + RtpobserverPause = 63, + + /// The variant `RTPOBSERVER_RESUME` in the enum `Method` + RtpobserverResume = 64, + + /// The variant `RTPOBSERVER_ADD_PRODUCER` in the enum `Method` + RtpobserverAddProducer = 65, + + /// The variant `RTPOBSERVER_REMOVE_PRODUCER` in the enum `Method` + RtpobserverRemoveProducer = 66, } - impl BodyBuilder<::planus::Initialized> { - /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. + impl Method { + /// Array containing all valid variants of Method + pub const ENUM_VALUES: [Self; 67] = [ + Self::WorkerClose, + Self::WorkerDump, + Self::WorkerGetResourceUsage, + Self::WorkerUpdateSettings, + Self::WorkerCreateWebrtcserver, + Self::WorkerCreateRouter, + Self::WorkerWebrtcserverClose, + Self::WorkerCloseRouter, + Self::WebrtcserverDump, + Self::RouterDump, + Self::RouterCreateWebrtctransport, + Self::RouterCreateWebrtctransportWithServer, + Self::RouterCreatePlaintransport, + Self::RouterCreatePipetransport, + Self::RouterCreateDirecttransport, + Self::RouterCloseTransport, + Self::RouterCreateActivespeakerobserver, + Self::RouterCreateAudiolevelobserver, + Self::RouterCloseRtpobserver, + Self::TransportDump, + Self::TransportGetStats, + Self::TransportConnect, + Self::TransportSetMaxIncomingBitrate, + Self::TransportSetMaxOutgoingBitrate, + Self::TransportSetMinOutgoingBitrate, + Self::TransportRestartIce, + Self::TransportProduce, + Self::TransportProduceData, + Self::TransportConsume, + Self::TransportConsumeData, + Self::TransportEnableTraceEvent, + Self::TransportCloseProducer, + Self::TransportCloseConsumer, + Self::TransportCloseDataproducer, + Self::TransportCloseDataconsumer, + Self::PlaintransportConnect, + Self::PipetransportConnect, + Self::WebrtctransportConnect, + Self::ProducerDump, + Self::ProducerGetStats, + Self::ProducerPause, + Self::ProducerResume, + Self::ProducerEnableTraceEvent, + Self::ConsumerDump, + Self::ConsumerGetStats, + Self::ConsumerPause, + Self::ConsumerResume, + Self::ConsumerSetPreferredLayers, + Self::ConsumerSetPriority, + Self::ConsumerRequestKeyFrame, + Self::ConsumerEnableTraceEvent, + Self::DataproducerDump, + Self::DataproducerGetStats, + Self::DataproducerPause, + Self::DataproducerResume, + Self::DataconsumerDump, + Self::DataconsumerGetStats, + Self::DataconsumerPause, + Self::DataconsumerResume, + Self::DataconsumerGetBufferedAmount, + Self::DataconsumerSetBufferedAmountLowThreshold, + Self::DataconsumerSend, + Self::DataconsumerSetSubchannels, + Self::RtpobserverPause, + Self::RtpobserverResume, + Self::RtpobserverAddProducer, + Self::RtpobserverRemoveProducer, + ]; + } + + impl ::core::convert::TryFrom for Method { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset - where - Self: ::planus::WriteAsUnion, + fn try_from( + value: u8, + ) -> ::core::result::Result { - ::planus::WriteAsUnion::prepare(&self, builder) + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(Method::WorkerClose), + 1 => ::core::result::Result::Ok(Method::WorkerDump), + 2 => ::core::result::Result::Ok(Method::WorkerGetResourceUsage), + 3 => ::core::result::Result::Ok(Method::WorkerUpdateSettings), + 4 => ::core::result::Result::Ok(Method::WorkerCreateWebrtcserver), + 5 => ::core::result::Result::Ok(Method::WorkerCreateRouter), + 6 => ::core::result::Result::Ok(Method::WorkerWebrtcserverClose), + 7 => ::core::result::Result::Ok(Method::WorkerCloseRouter), + 8 => ::core::result::Result::Ok(Method::WebrtcserverDump), + 9 => ::core::result::Result::Ok(Method::RouterDump), + 10 => ::core::result::Result::Ok(Method::RouterCreateWebrtctransport), + 11 => ::core::result::Result::Ok( + Method::RouterCreateWebrtctransportWithServer, + ), + 12 => ::core::result::Result::Ok(Method::RouterCreatePlaintransport), + 13 => ::core::result::Result::Ok(Method::RouterCreatePipetransport), + 14 => ::core::result::Result::Ok(Method::RouterCreateDirecttransport), + 15 => ::core::result::Result::Ok(Method::RouterCloseTransport), + 16 => ::core::result::Result::Ok(Method::RouterCreateActivespeakerobserver), + 17 => ::core::result::Result::Ok(Method::RouterCreateAudiolevelobserver), + 18 => ::core::result::Result::Ok(Method::RouterCloseRtpobserver), + 19 => ::core::result::Result::Ok(Method::TransportDump), + 20 => ::core::result::Result::Ok(Method::TransportGetStats), + 21 => ::core::result::Result::Ok(Method::TransportConnect), + 22 => ::core::result::Result::Ok(Method::TransportSetMaxIncomingBitrate), + 23 => ::core::result::Result::Ok(Method::TransportSetMaxOutgoingBitrate), + 24 => ::core::result::Result::Ok(Method::TransportSetMinOutgoingBitrate), + 25 => ::core::result::Result::Ok(Method::TransportRestartIce), + 26 => ::core::result::Result::Ok(Method::TransportProduce), + 27 => ::core::result::Result::Ok(Method::TransportProduceData), + 28 => ::core::result::Result::Ok(Method::TransportConsume), + 29 => ::core::result::Result::Ok(Method::TransportConsumeData), + 30 => ::core::result::Result::Ok(Method::TransportEnableTraceEvent), + 31 => ::core::result::Result::Ok(Method::TransportCloseProducer), + 32 => ::core::result::Result::Ok(Method::TransportCloseConsumer), + 33 => ::core::result::Result::Ok(Method::TransportCloseDataproducer), + 34 => ::core::result::Result::Ok(Method::TransportCloseDataconsumer), + 35 => ::core::result::Result::Ok(Method::PlaintransportConnect), + 36 => ::core::result::Result::Ok(Method::PipetransportConnect), + 37 => ::core::result::Result::Ok(Method::WebrtctransportConnect), + 38 => ::core::result::Result::Ok(Method::ProducerDump), + 39 => ::core::result::Result::Ok(Method::ProducerGetStats), + 40 => ::core::result::Result::Ok(Method::ProducerPause), + 41 => ::core::result::Result::Ok(Method::ProducerResume), + 42 => ::core::result::Result::Ok(Method::ProducerEnableTraceEvent), + 43 => ::core::result::Result::Ok(Method::ConsumerDump), + 44 => ::core::result::Result::Ok(Method::ConsumerGetStats), + 45 => ::core::result::Result::Ok(Method::ConsumerPause), + 46 => ::core::result::Result::Ok(Method::ConsumerResume), + 47 => ::core::result::Result::Ok(Method::ConsumerSetPreferredLayers), + 48 => ::core::result::Result::Ok(Method::ConsumerSetPriority), + 49 => ::core::result::Result::Ok(Method::ConsumerRequestKeyFrame), + 50 => ::core::result::Result::Ok(Method::ConsumerEnableTraceEvent), + 51 => ::core::result::Result::Ok(Method::DataproducerDump), + 52 => ::core::result::Result::Ok(Method::DataproducerGetStats), + 53 => ::core::result::Result::Ok(Method::DataproducerPause), + 54 => ::core::result::Result::Ok(Method::DataproducerResume), + 55 => ::core::result::Result::Ok(Method::DataconsumerDump), + 56 => ::core::result::Result::Ok(Method::DataconsumerGetStats), + 57 => ::core::result::Result::Ok(Method::DataconsumerPause), + 58 => ::core::result::Result::Ok(Method::DataconsumerResume), + 59 => ::core::result::Result::Ok(Method::DataconsumerGetBufferedAmount), + 60 => ::core::result::Result::Ok( + Method::DataconsumerSetBufferedAmountLowThreshold, + ), + 61 => ::core::result::Result::Ok(Method::DataconsumerSend), + 62 => ::core::result::Result::Ok(Method::DataconsumerSetSubchannels), + 63 => ::core::result::Result::Ok(Method::RtpobserverPause), + 64 => ::core::result::Result::Ok(Method::RtpobserverResume), + 65 => ::core::result::Result::Ok(Method::RtpobserverAddProducer), + 66 => ::core::result::Result::Ok(Method::RtpobserverRemoveProducer), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::core::convert::From for u8 { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) + fn from(value: Method) -> Self { + value as u8 } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::Primitive for Method { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } + + impl ::planus::WriteAsPrimitive for Method { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::WriteAs for Method { + type Prepared = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Method { + *self } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsDefault for Method { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) + _builder: &mut ::planus::Builder, + default: &Method, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptional for Method { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'buf> ::planus::TableRead<'buf> for Method { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + impl<'buf> ::planus::VectorReadInner<'buf> for Method { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "Method", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::VectorWrite for Method { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + unsafe fn write_values( + values: &[Self], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - i as u32, + ); + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { + + /// The union `Body` in the namespace `FBS.Request` + /// + /// Generated from these locations: + /// * Union `Body` in the file `../worker/fbs/request.fbs:81` + #[derive( + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + )] + pub enum Body { + /// The variant of type `FBS.Worker.UpdateSettingsRequest` in the union `Body` + UpdateSettingsRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Worker.CreateWebRtcServerRequest` in the union `Body` + CreateWebRtcServerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Worker.CloseWebRtcServerRequest` in the union `Body` + CloseWebRtcServerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Worker.CreateRouterRequest` in the union `Body` + CreateRouterRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Worker.CloseRouterRequest` in the union `Body` + CloseRouterRequest(::planus::alloc::boxed::Box), + + /// The variant of type `FBS.Router.CreateWebRtcTransportRequest` in the union `Body` + CreateWebRtcTransportRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CreatePlainTransportRequest` in the union `Body` + CreatePlainTransportRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CreatePipeTransportRequest` in the union `Body` + CreatePipeTransportRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CreateDirectTransportRequest` in the union `Body` + CreateDirectTransportRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CreateActiveSpeakerObserverRequest` in the union `Body` + CreateActiveSpeakerObserverRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CreateAudioLevelObserverRequest` in the union `Body` + CreateAudioLevelObserverRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CloseTransportRequest` in the union `Body` + CloseTransportRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Router.CloseRtpObserverRequest` in the union `Body` + CloseRtpObserverRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.SetMaxIncomingBitrateRequest` in the union `Body` + SetMaxIncomingBitrateRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.SetMaxOutgoingBitrateRequest` in the union `Body` + SetMaxOutgoingBitrateRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.SetMinOutgoingBitrateRequest` in the union `Body` + SetMinOutgoingBitrateRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.ProduceRequest` in the union `Body` + ProduceRequest(::planus::alloc::boxed::Box), + + /// The variant of type `FBS.Transport.ConsumeRequest` in the union `Body` + ConsumeRequest(::planus::alloc::boxed::Box), + + /// The variant of type `FBS.Transport.ProduceDataRequest` in the union `Body` + ProduceDataRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.ConsumeDataRequest` in the union `Body` + ConsumeDataRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Consumer.EnableTraceEventRequest` in the union `Body` + EnableTraceEventRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.CloseProducerRequest` in the union `Body` + CloseProducerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.CloseConsumerRequest` in the union `Body` + CloseConsumerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.CloseDataProducerRequest` in the union `Body` + CloseDataProducerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Transport.CloseDataConsumerRequest` in the union `Body` + CloseDataConsumerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant `PlainTransport_ConnectRequest` in the union `Body` + PlainTransportConnectRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant `PipeTransport_ConnectRequest` in the union `Body` + PipeTransportConnectRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant `WebRtcTransport_ConnectRequest` in the union `Body` + WebRtcTransportConnectRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Consumer.SetPreferredLayersRequest` in the union `Body` + SetPreferredLayersRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.Consumer.SetPriorityRequest` in the union `Body` + SetPriorityRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.DataConsumer.SetBufferedAmountLowThresholdRequest` in the union `Body` + SetBufferedAmountLowThresholdRequest( + ::planus::alloc::boxed::Box< + super::data_consumer::SetBufferedAmountLowThresholdRequest, + >, + ), + + /// The variant of type `FBS.DataConsumer.SendRequest` in the union `Body` + SendRequest(::planus::alloc::boxed::Box), + + /// The variant of type `FBS.DataConsumer.SetSubchannelsRequest` in the union `Body` + SetSubchannelsRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.RtpObserver.AddProducerRequest` in the union `Body` + AddProducerRequest( + ::planus::alloc::boxed::Box, + ), + + /// The variant of type `FBS.RtpObserver.RemoveProducerRequest` in the union `Body` + RemoveProducerRequest( + ::planus::alloc::boxed::Box, + ), + } + + impl Body { + /// Creates a [BodyBuilder] for serializing an instance of this table. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) + pub fn builder() -> BodyBuilder<::planus::Uninitialized> { + BodyBuilder(::planus::Uninitialized) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_update_settings_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) + pub fn create_create_web_rtc_server_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_close_web_rtc_server_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) + pub fn create_create_router_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_close_router_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) + pub fn create_create_web_rtc_transport_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_create_plain_transport_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) + pub fn create_create_pipe_transport_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_create_direct_transport_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) + pub fn create_create_active_speaker_observer_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset< + super::router::CreateActiveSpeakerObserverRequest, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_create_audio_level_observer_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) + pub fn create_close_transport_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_close_rtp_observer_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) + pub fn create_set_max_incoming_bitrate_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_set_max_outgoing_bitrate_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) + pub fn create_set_min_outgoing_bitrate_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_produce_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) + pub fn create_consume_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_produce_data_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(19, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) + pub fn create_consume_data_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(20, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_enable_trace_event_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(21, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) + pub fn create_close_producer_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(22, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_close_consumer_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(23, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) + pub fn create_close_data_producer_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(24, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_close_data_consumer_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(25, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(19, (self.0).0.prepare(builder).downcast()) + pub fn create_plain_transport_connect_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(26, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_pipe_transport_connect_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(27, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(20, (self.0).0.prepare(builder).downcast()) + pub fn create_web_rtc_transport_connect_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(28, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_set_preferred_layers_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(29, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<21, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(21, (self.0).0.prepare(builder).downcast()) + pub fn create_set_priority_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(30, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<21, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_set_buffered_amount_low_threshold_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset< + super::data_consumer::SetBufferedAmountLowThresholdRequest, + >, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(31, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(22, (self.0).0.prepare(builder).downcast()) + pub fn create_send_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(32, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_set_subchannels_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(33, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<23, T>> - where - T: ::planus::WriteAsOffset, - { + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(23, (self.0).0.prepare(builder).downcast()) + pub fn create_add_producer_request( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(34, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<23, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, + pub fn create_remove_producer_request( builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(35, value.prepare(builder).downcast()) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::WriteAsUnion for Body { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(24, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + match self { + Self::UpdateSettingsRequest(value) => { + Self::create_update_settings_request(builder, value) + } + Self::CreateWebRtcServerRequest(value) => { + Self::create_create_web_rtc_server_request(builder, value) + } + Self::CloseWebRtcServerRequest(value) => { + Self::create_close_web_rtc_server_request(builder, value) + } + Self::CreateRouterRequest(value) => { + Self::create_create_router_request(builder, value) + } + Self::CloseRouterRequest(value) => { + Self::create_close_router_request(builder, value) + } + Self::CreateWebRtcTransportRequest(value) => { + Self::create_create_web_rtc_transport_request(builder, value) + } + Self::CreatePlainTransportRequest(value) => { + Self::create_create_plain_transport_request(builder, value) + } + Self::CreatePipeTransportRequest(value) => { + Self::create_create_pipe_transport_request(builder, value) + } + Self::CreateDirectTransportRequest(value) => { + Self::create_create_direct_transport_request(builder, value) + } + Self::CreateActiveSpeakerObserverRequest(value) => { + Self::create_create_active_speaker_observer_request(builder, value) + } + Self::CreateAudioLevelObserverRequest(value) => { + Self::create_create_audio_level_observer_request(builder, value) + } + Self::CloseTransportRequest(value) => { + Self::create_close_transport_request(builder, value) + } + Self::CloseRtpObserverRequest(value) => { + Self::create_close_rtp_observer_request(builder, value) + } + Self::SetMaxIncomingBitrateRequest(value) => { + Self::create_set_max_incoming_bitrate_request(builder, value) + } + Self::SetMaxOutgoingBitrateRequest(value) => { + Self::create_set_max_outgoing_bitrate_request(builder, value) + } + Self::SetMinOutgoingBitrateRequest(value) => { + Self::create_set_min_outgoing_bitrate_request(builder, value) + } + Self::ProduceRequest(value) => Self::create_produce_request(builder, value), + Self::ConsumeRequest(value) => Self::create_consume_request(builder, value), + Self::ProduceDataRequest(value) => { + Self::create_produce_data_request(builder, value) + } + Self::ConsumeDataRequest(value) => { + Self::create_consume_data_request(builder, value) + } + Self::EnableTraceEventRequest(value) => { + Self::create_enable_trace_event_request(builder, value) + } + Self::CloseProducerRequest(value) => { + Self::create_close_producer_request(builder, value) + } + Self::CloseConsumerRequest(value) => { + Self::create_close_consumer_request(builder, value) + } + Self::CloseDataProducerRequest(value) => { + Self::create_close_data_producer_request(builder, value) + } + Self::CloseDataConsumerRequest(value) => { + Self::create_close_data_consumer_request(builder, value) + } + Self::PlainTransportConnectRequest(value) => { + Self::create_plain_transport_connect_request(builder, value) + } + Self::PipeTransportConnectRequest(value) => { + Self::create_pipe_transport_connect_request(builder, value) + } + Self::WebRtcTransportConnectRequest(value) => { + Self::create_web_rtc_transport_connect_request(builder, value) + } + Self::SetPreferredLayersRequest(value) => { + Self::create_set_preferred_layers_request(builder, value) + } + Self::SetPriorityRequest(value) => { + Self::create_set_priority_request(builder, value) + } + Self::SetBufferedAmountLowThresholdRequest(value) => { + Self::create_set_buffered_amount_low_threshold_request(builder, value) + } + Self::SendRequest(value) => Self::create_send_request(builder, value), + Self::SetSubchannelsRequest(value) => { + Self::create_set_subchannels_request(builder, value) + } + Self::AddProducerRequest(value) => { + Self::create_add_producer_request(builder, value) + } + Self::RemoveProducerRequest(value) => { + Self::create_remove_producer_request(builder, value) + } + } } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptionalUnion for Body { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { + ) -> ::core::option::Option<::planus::UnionOffset> { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<25, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(25, (self.0).0.prepare(builder).downcast()) - } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<25, T>> - where - T: ::planus::WriteAsOffset, - { + /// Builder for serializing an instance of the [Body] type. + /// + /// Can be created using the [Body::builder] method. + #[derive(Debug)] + #[must_use] + pub struct BodyBuilder(T); + + impl BodyBuilder<::planus::Uninitialized> { + /// Creates an instance of the [`UpdateSettingsRequest` variant](Body#variant.UpdateSettingsRequest). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn update_settings_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Creates an instance of the [`CreateWebRtcServerRequest` variant](Body#variant.CreateWebRtcServerRequest). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(26, (self.0).0.prepare(builder).downcast()) + pub fn create_web_rtc_server_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { + /// Creates an instance of the [`CloseWebRtcServerRequest` variant](Body#variant.CloseWebRtcServerRequest). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn close_web_rtc_server_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<27, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Creates an instance of the [`CreateRouterRequest` variant](Body#variant.CreateRouterRequest). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(27, (self.0).0.prepare(builder).downcast()) + pub fn create_router_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<27, T>> - where - T: ::planus::WriteAsOffset, - { + /// Creates an instance of the [`CloseRouterRequest` variant](Body#variant.CloseRouterRequest). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn close_router_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Creates an instance of the [`CreateWebRtcTransportRequest` variant](Body#variant.CreateWebRtcTransportRequest). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(28, (self.0).0.prepare(builder).downcast()) + pub fn create_web_rtc_transport_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { + /// Creates an instance of the [`CreatePlainTransportRequest` variant](Body#variant.CreatePlainTransportRequest). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn create_plain_transport_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<29, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Creates an instance of the [`CreatePipeTransportRequest` variant](Body#variant.CreatePipeTransportRequest). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(29, (self.0).0.prepare(builder).downcast()) + pub fn create_pipe_transport_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<29, T>> - where - T: ::planus::WriteAsOffset, - { + /// Creates an instance of the [`CreateDirectTransportRequest` variant](Body#variant.CreateDirectTransportRequest). #[inline] - fn prepare( - &self, + pub fn create_direct_transport_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CreateActiveSpeakerObserverRequest` variant](Body#variant.CreateActiveSpeakerObserverRequest). + #[inline] + pub fn create_active_speaker_observer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CreateAudioLevelObserverRequest` variant](Body#variant.CreateAudioLevelObserverRequest). + #[inline] + pub fn create_audio_level_observer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseTransportRequest` variant](Body#variant.CloseTransportRequest). + #[inline] + pub fn close_transport_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseRtpObserverRequest` variant](Body#variant.CloseRtpObserverRequest). + #[inline] + pub fn close_rtp_observer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetMaxIncomingBitrateRequest` variant](Body#variant.SetMaxIncomingBitrateRequest). + #[inline] + pub fn set_max_incoming_bitrate_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetMaxOutgoingBitrateRequest` variant](Body#variant.SetMaxOutgoingBitrateRequest). + #[inline] + pub fn set_max_outgoing_bitrate_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetMinOutgoingBitrateRequest` variant](Body#variant.SetMinOutgoingBitrateRequest). + #[inline] + pub fn set_min_outgoing_bitrate_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`ProduceRequest` variant](Body#variant.ProduceRequest). + #[inline] + pub fn produce_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`ConsumeRequest` variant](Body#variant.ConsumeRequest). + #[inline] + pub fn consume_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`ProduceDataRequest` variant](Body#variant.ProduceDataRequest). + #[inline] + pub fn produce_data_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`ConsumeDataRequest` variant](Body#variant.ConsumeDataRequest). + #[inline] + pub fn consume_data_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`EnableTraceEventRequest` variant](Body#variant.EnableTraceEventRequest). + #[inline] + pub fn enable_trace_event_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseProducerRequest` variant](Body#variant.CloseProducerRequest). + #[inline] + pub fn close_producer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseConsumerRequest` variant](Body#variant.CloseConsumerRequest). + #[inline] + pub fn close_consumer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<23, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseDataProducerRequest` variant](Body#variant.CloseDataProducerRequest). + #[inline] + pub fn close_data_producer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`CloseDataConsumerRequest` variant](Body#variant.CloseDataConsumerRequest). + #[inline] + pub fn close_data_consumer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<25, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`PlainTransport_ConnectRequest` variant](Body#variant.PlainTransportConnectRequest). + #[inline] + pub fn plain_transport_connect_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`PipeTransport_ConnectRequest` variant](Body#variant.PipeTransportConnectRequest). + #[inline] + pub fn pipe_transport_connect_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<27, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`WebRtcTransport_ConnectRequest` variant](Body#variant.WebRtcTransportConnectRequest). + #[inline] + pub fn web_rtc_transport_connect_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<28, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetPreferredLayersRequest` variant](Body#variant.SetPreferredLayersRequest). + #[inline] + pub fn set_preferred_layers_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetPriorityRequest` variant](Body#variant.SetPriorityRequest). + #[inline] + pub fn set_priority_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetBufferedAmountLowThresholdRequest` variant](Body#variant.SetBufferedAmountLowThresholdRequest). + #[inline] + pub fn set_buffered_amount_low_threshold_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<31, T>> + where + T: ::planus::WriteAsOffset< + super::data_consumer::SetBufferedAmountLowThresholdRequest, + >, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SendRequest` variant](Body#variant.SendRequest). + #[inline] + pub fn send_request(self, value: T) -> BodyBuilder<::planus::Initialized<32, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`SetSubchannelsRequest` variant](Body#variant.SetSubchannelsRequest). + #[inline] + pub fn set_subchannels_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<33, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`AddProducerRequest` variant](Body#variant.AddProducerRequest). + #[inline] + pub fn add_producer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<34, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`RemoveProducerRequest` variant](Body#variant.RemoveProducerRequest). + #[inline] + pub fn remove_producer_request( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<35, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + } + + impl BodyBuilder<::planus::Initialized> { + /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. + #[inline] + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset + where + Self: ::planus::WriteAsUnion, + { + ::planus::WriteAsUnion::prepare(&self, builder) + } + } + + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, builder: &mut ::planus::Builder, ) -> ::core::option::Option<::planus::UnionOffset> { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<30, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(30, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<30, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52882,23 +52518,19 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<31, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> where - T: ::planus::WriteAsOffset< - super::data_consumer::SetBufferedAmountLowThresholdRequest, - >, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(31, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<31, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> where - T: ::planus::WriteAsOffset< - super::data_consumer::SetBufferedAmountLowThresholdRequest, - >, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52908,19 +52540,19 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<32, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(32, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<32, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52930,19 +52562,19 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<33, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(33, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<33, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52952,19 +52584,19 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<34, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(34, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<34, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52974,19 +52606,19 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<35, T>> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(35, (self.0).0.prepare(builder).downcast()) + ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<35, T>> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> where - T: ::planus::WriteAsOffset, + T: ::planus::WriteAsOffset, { #[inline] fn prepare( @@ -52996,3432 +52628,5877 @@ mod root { ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) + } + } - /// Reference to a deserialized [Body]. - #[derive(Copy, Clone, Debug)] - pub enum BodyRef<'a> { - UpdateSettingsRequest(super::worker::UpdateSettingsRequestRef<'a>), - CreateWebRtcServerRequest(super::worker::CreateWebRtcServerRequestRef<'a>), - CloseWebRtcServerRequest(super::worker::CloseWebRtcServerRequestRef<'a>), - CreateRouterRequest(super::worker::CreateRouterRequestRef<'a>), - CloseRouterRequest(super::worker::CloseRouterRequestRef<'a>), - CreateWebRtcTransportRequest(super::router::CreateWebRtcTransportRequestRef<'a>), - CreatePlainTransportRequest(super::router::CreatePlainTransportRequestRef<'a>), - CreatePipeTransportRequest(super::router::CreatePipeTransportRequestRef<'a>), - CreateDirectTransportRequest(super::router::CreateDirectTransportRequestRef<'a>), - CreateActiveSpeakerObserverRequest( - super::router::CreateActiveSpeakerObserverRequestRef<'a>, - ), - CreateAudioLevelObserverRequest( - super::router::CreateAudioLevelObserverRequestRef<'a>, - ), - CloseTransportRequest(super::router::CloseTransportRequestRef<'a>), - CloseRtpObserverRequest(super::router::CloseRtpObserverRequestRef<'a>), - SetMaxIncomingBitrateRequest(super::transport::SetMaxIncomingBitrateRequestRef<'a>), - SetMaxOutgoingBitrateRequest(super::transport::SetMaxOutgoingBitrateRequestRef<'a>), - SetMinOutgoingBitrateRequest(super::transport::SetMinOutgoingBitrateRequestRef<'a>), - ProduceRequest(super::transport::ProduceRequestRef<'a>), - ConsumeRequest(super::transport::ConsumeRequestRef<'a>), - ProduceDataRequest(super::transport::ProduceDataRequestRef<'a>), - ConsumeDataRequest(super::transport::ConsumeDataRequestRef<'a>), - EnableTraceEventRequest(super::consumer::EnableTraceEventRequestRef<'a>), - CloseProducerRequest(super::transport::CloseProducerRequestRef<'a>), - CloseConsumerRequest(super::transport::CloseConsumerRequestRef<'a>), - CloseDataProducerRequest(super::transport::CloseDataProducerRequestRef<'a>), - CloseDataConsumerRequest(super::transport::CloseDataConsumerRequestRef<'a>), - PlainTransportConnectRequest(super::plain_transport::ConnectRequestRef<'a>), - PipeTransportConnectRequest(super::pipe_transport::ConnectRequestRef<'a>), - ConnectRequest(super::web_rtc_transport::ConnectRequestRef<'a>), - SetPreferredLayersRequest(super::consumer::SetPreferredLayersRequestRef<'a>), - SetPriorityRequest(super::consumer::SetPriorityRequestRef<'a>), - SetBufferedAmountLowThresholdRequest( - super::data_consumer::SetBufferedAmountLowThresholdRequestRef<'a>, - ), - SendRequest(super::data_consumer::SendRequestRef<'a>), - SetSubchannelsRequest(super::data_consumer::SetSubchannelsRequestRef<'a>), - AddProducerRequest(super::rtp_observer::AddProducerRequestRef<'a>), - RemoveProducerRequest(super::rtp_observer::RemoveProducerRequestRef<'a>), + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) + } } - impl<'a> ::core::convert::TryFrom> for Body { - type Error = ::planus::Error; + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) + } + } - fn try_from(value: BodyRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - BodyRef::UpdateSettingsRequest(value) => { - Self::UpdateSettingsRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(19, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(20, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(21, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(22, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<23, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(23, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<23, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(24, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<25, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(25, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<25, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(26, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<27, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(27, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<27, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<28, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(28, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<28, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(29, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(30, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<31, T>> + where + T: ::planus::WriteAsOffset< + super::data_consumer::SetBufferedAmountLowThresholdRequest, + >, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(31, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<31, T>> + where + T: ::planus::WriteAsOffset< + super::data_consumer::SetBufferedAmountLowThresholdRequest, + >, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<32, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(32, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<32, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<33, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(33, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<33, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<34, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(34, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<34, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<35, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(35, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<35, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + + /// Reference to a deserialized [Body]. + #[derive(Copy, Clone, Debug)] + pub enum BodyRef<'a> { + UpdateSettingsRequest(super::worker::UpdateSettingsRequestRef<'a>), + CreateWebRtcServerRequest(super::worker::CreateWebRtcServerRequestRef<'a>), + CloseWebRtcServerRequest(super::worker::CloseWebRtcServerRequestRef<'a>), + CreateRouterRequest(super::worker::CreateRouterRequestRef<'a>), + CloseRouterRequest(super::worker::CloseRouterRequestRef<'a>), + CreateWebRtcTransportRequest(super::router::CreateWebRtcTransportRequestRef<'a>), + CreatePlainTransportRequest(super::router::CreatePlainTransportRequestRef<'a>), + CreatePipeTransportRequest(super::router::CreatePipeTransportRequestRef<'a>), + CreateDirectTransportRequest(super::router::CreateDirectTransportRequestRef<'a>), + CreateActiveSpeakerObserverRequest( + super::router::CreateActiveSpeakerObserverRequestRef<'a>, + ), + CreateAudioLevelObserverRequest( + super::router::CreateAudioLevelObserverRequestRef<'a>, + ), + CloseTransportRequest(super::router::CloseTransportRequestRef<'a>), + CloseRtpObserverRequest(super::router::CloseRtpObserverRequestRef<'a>), + SetMaxIncomingBitrateRequest(super::transport::SetMaxIncomingBitrateRequestRef<'a>), + SetMaxOutgoingBitrateRequest(super::transport::SetMaxOutgoingBitrateRequestRef<'a>), + SetMinOutgoingBitrateRequest(super::transport::SetMinOutgoingBitrateRequestRef<'a>), + ProduceRequest(super::transport::ProduceRequestRef<'a>), + ConsumeRequest(super::transport::ConsumeRequestRef<'a>), + ProduceDataRequest(super::transport::ProduceDataRequestRef<'a>), + ConsumeDataRequest(super::transport::ConsumeDataRequestRef<'a>), + EnableTraceEventRequest(super::consumer::EnableTraceEventRequestRef<'a>), + CloseProducerRequest(super::transport::CloseProducerRequestRef<'a>), + CloseConsumerRequest(super::transport::CloseConsumerRequestRef<'a>), + CloseDataProducerRequest(super::transport::CloseDataProducerRequestRef<'a>), + CloseDataConsumerRequest(super::transport::CloseDataConsumerRequestRef<'a>), + PlainTransportConnectRequest(super::plain_transport::ConnectRequestRef<'a>), + PipeTransportConnectRequest(super::pipe_transport::ConnectRequestRef<'a>), + WebRtcTransportConnectRequest(super::web_rtc_transport::ConnectRequestRef<'a>), + SetPreferredLayersRequest(super::consumer::SetPreferredLayersRequestRef<'a>), + SetPriorityRequest(super::consumer::SetPriorityRequestRef<'a>), + SetBufferedAmountLowThresholdRequest( + super::data_consumer::SetBufferedAmountLowThresholdRequestRef<'a>, + ), + SendRequest(super::data_consumer::SendRequestRef<'a>), + SetSubchannelsRequest(super::data_consumer::SetSubchannelsRequestRef<'a>), + AddProducerRequest(super::rtp_observer::AddProducerRequestRef<'a>), + RemoveProducerRequest(super::rtp_observer::RemoveProducerRequestRef<'a>), + } + + impl<'a> ::core::convert::TryFrom> for Body { + type Error = ::planus::Error; + + fn try_from(value: BodyRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + BodyRef::UpdateSettingsRequest(value) => { + Self::UpdateSettingsRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreateWebRtcServerRequest(value) => { + Self::CreateWebRtcServerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseWebRtcServerRequest(value) => { + Self::CloseWebRtcServerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreateRouterRequest(value) => { + Self::CreateRouterRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseRouterRequest(value) => { + Self::CloseRouterRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreateWebRtcTransportRequest(value) => { + Self::CreateWebRtcTransportRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreatePlainTransportRequest(value) => { + Self::CreatePlainTransportRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreatePipeTransportRequest(value) => { + Self::CreatePipeTransportRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreateDirectTransportRequest(value) => { + Self::CreateDirectTransportRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CreateActiveSpeakerObserverRequest(value) => { + Self::CreateActiveSpeakerObserverRequest( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) + } + + BodyRef::CreateAudioLevelObserverRequest(value) => { + Self::CreateAudioLevelObserverRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseTransportRequest(value) => { + Self::CloseTransportRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseRtpObserverRequest(value) => { + Self::CloseRtpObserverRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetMaxIncomingBitrateRequest(value) => { + Self::SetMaxIncomingBitrateRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetMaxOutgoingBitrateRequest(value) => { + Self::SetMaxOutgoingBitrateRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetMinOutgoingBitrateRequest(value) => { + Self::SetMinOutgoingBitrateRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::ProduceRequest(value) => { + Self::ProduceRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::ConsumeRequest(value) => { + Self::ConsumeRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::ProduceDataRequest(value) => { + Self::ProduceDataRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::ConsumeDataRequest(value) => { + Self::ConsumeDataRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::EnableTraceEventRequest(value) => { + Self::EnableTraceEventRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseProducerRequest(value) => { + Self::CloseProducerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseConsumerRequest(value) => { + Self::CloseConsumerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseDataProducerRequest(value) => { + Self::CloseDataProducerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::CloseDataConsumerRequest(value) => { + Self::CloseDataConsumerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::PlainTransportConnectRequest(value) => { + Self::PlainTransportConnectRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::PipeTransportConnectRequest(value) => { + Self::PipeTransportConnectRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::WebRtcTransportConnectRequest(value) => { + Self::WebRtcTransportConnectRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetPreferredLayersRequest(value) => { + Self::SetPreferredLayersRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetPriorityRequest(value) => { + Self::SetPriorityRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetBufferedAmountLowThresholdRequest(value) => { + Self::SetBufferedAmountLowThresholdRequest( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) + } + + BodyRef::SendRequest(value) => { + Self::SendRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::SetSubchannelsRequest(value) => { + Self::SetSubchannelsRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + BodyRef::AddProducerRequest(value) => { + Self::AddProducerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, )) } - BodyRef::CreateWebRtcServerRequest(value) => { - Self::CreateWebRtcServerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + BodyRef::RemoveProducerRequest(value) => { + Self::RemoveProducerRequest(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + }) + } + } + + impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + field_offset: usize, + tag: u8, + ) -> ::core::result::Result { + match tag { + 1 => ::core::result::Result::Ok(Self::UpdateSettingsRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::CreateWebRtcServerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 3 => ::core::result::Result::Ok(Self::CloseWebRtcServerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 4 => ::core::result::Result::Ok(Self::CreateRouterRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 5 => ::core::result::Result::Ok(Self::CloseRouterRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 6 => ::core::result::Result::Ok(Self::CreateWebRtcTransportRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 7 => ::core::result::Result::Ok(Self::CreatePlainTransportRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 8 => ::core::result::Result::Ok(Self::CreatePipeTransportRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 9 => ::core::result::Result::Ok(Self::CreateDirectTransportRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 10 => ::core::result::Result::Ok(Self::CreateActiveSpeakerObserverRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 11 => ::core::result::Result::Ok(Self::CreateAudioLevelObserverRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 12 => ::core::result::Result::Ok(Self::CloseTransportRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 13 => ::core::result::Result::Ok(Self::CloseRtpObserverRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 14 => ::core::result::Result::Ok(Self::SetMaxIncomingBitrateRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 15 => ::core::result::Result::Ok(Self::SetMaxOutgoingBitrateRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 16 => ::core::result::Result::Ok(Self::SetMinOutgoingBitrateRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 17 => ::core::result::Result::Ok(Self::ProduceRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 18 => ::core::result::Result::Ok(Self::ConsumeRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 19 => ::core::result::Result::Ok(Self::ProduceDataRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 20 => ::core::result::Result::Ok(Self::ConsumeDataRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 21 => ::core::result::Result::Ok(Self::EnableTraceEventRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 22 => ::core::result::Result::Ok(Self::CloseProducerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 23 => ::core::result::Result::Ok(Self::CloseConsumerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 24 => ::core::result::Result::Ok(Self::CloseDataProducerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 25 => ::core::result::Result::Ok(Self::CloseDataConsumerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 26 => ::core::result::Result::Ok(Self::PlainTransportConnectRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 27 => ::core::result::Result::Ok(Self::PipeTransportConnectRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 28 => ::core::result::Result::Ok(Self::WebRtcTransportConnectRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 29 => ::core::result::Result::Ok(Self::SetPreferredLayersRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 30 => ::core::result::Result::Ok(Self::SetPriorityRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 31 => { + ::core::result::Result::Ok(Self::SetBufferedAmountLowThresholdRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )) + } + 32 => ::core::result::Result::Ok(Self::SendRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 33 => ::core::result::Result::Ok(Self::SetSubchannelsRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 34 => ::core::result::Result::Ok(Self::AddProducerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 35 => ::core::result::Result::Ok(Self::RemoveProducerRequest( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), + } + } + } + + /// The table `Request` in the namespace `FBS.Request` + /// + /// Generated from these locations: + /// * Table `Request` in the file `../worker/fbs/request.fbs:121` + #[derive( + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + )] + pub struct Request { + /// The field `id` in the table `Request` + pub id: u32, + /// The field `method` in the table `Request` + pub method: self::Method, + /// The field `handler_id` in the table `Request` + pub handler_id: ::planus::alloc::string::String, + /// The field `body` in the table `Request` + pub body: ::core::option::Option, + } + + impl Request { + /// Creates a [RequestBuilder] for serializing an instance of this table. + #[inline] + pub fn builder() -> RequestBuilder<()> { + RequestBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_id: impl ::planus::WriteAsDefault, + field_method: impl ::planus::WriteAsDefault, + field_handler_id: impl ::planus::WriteAs<::planus::Offset>, + field_body: impl ::planus::WriteAsOptionalUnion, + ) -> ::planus::Offset { + let prepared_id = field_id.prepare(builder, &0); + let prepared_method = field_method.prepare(builder, &self::Method::WorkerClose); + let prepared_handler_id = field_handler_id.prepare(builder); + let prepared_body = field_body.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<14> = + ::core::default::Default::default(); + if prepared_id.is_some() { + table_writer.write_entry::(0); + } + table_writer.write_entry::<::planus::Offset>(2); + if prepared_body.is_some() { + table_writer.write_entry::<::planus::Offset>(4); + } + if prepared_method.is_some() { + table_writer.write_entry::(1); + } + if prepared_body.is_some() { + table_writer.write_entry::(3); + } + + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_id) = prepared_id { + object_writer.write::<_, _, 4>(&prepared_id); + } + object_writer.write::<_, _, 4>(&prepared_handler_id); + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 4>(&prepared_body.offset()); + } + if let ::core::option::Option::Some(prepared_method) = prepared_method { + object_writer.write::<_, _, 1>(&prepared_method); + } + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 1>(&prepared_body.tag()); + } + }); + } + builder.current_offset() + } + } + + impl ::planus::WriteAs<::planus::Offset> for Request { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) + } + } + + impl ::planus::WriteAsOptional<::planus::Offset> for Request { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + } + } + + impl ::planus::WriteAsOffset for Request { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + Request::create(builder, self.id, self.method, &self.handler_id, &self.body) + } + } + + /// Builder for serializing an instance of the [Request] type. + /// + /// Can be created using the [Request::builder] method. + #[derive(Debug)] + #[must_use] + pub struct RequestBuilder(State); + + impl RequestBuilder<()> { + /// Setter for the [`id` field](Request#structfield.id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn id(self, value: T0) -> RequestBuilder<(T0,)> + where + T0: ::planus::WriteAsDefault, + { + RequestBuilder((value,)) + } + + /// Sets the [`id` field](Request#structfield.id) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn id_as_default(self) -> RequestBuilder<(::planus::DefaultValue,)> { + self.id(::planus::DefaultValue) + } + } + + impl RequestBuilder<(T0,)> { + /// Setter for the [`method` field](Request#structfield.method). + #[inline] + #[allow(clippy::type_complexity)] + pub fn method(self, value: T1) -> RequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAsDefault, + { + let (v0,) = self.0; + RequestBuilder((v0, value)) + } + + /// Sets the [`method` field](Request#structfield.method) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn method_as_default(self) -> RequestBuilder<(T0, ::planus::DefaultValue)> { + self.method(::planus::DefaultValue) + } + } + + impl RequestBuilder<(T0, T1)> { + /// Setter for the [`handler_id` field](Request#structfield.handler_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn handler_id(self, value: T2) -> RequestBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAs<::planus::Offset>, + { + let (v0, v1) = self.0; + RequestBuilder((v0, v1, value)) + } + } + + impl RequestBuilder<(T0, T1, T2)> { + /// Setter for the [`body` field](Request#structfield.body). + #[inline] + #[allow(clippy::type_complexity)] + pub fn body(self, value: T3) -> RequestBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAsOptionalUnion, + { + let (v0, v1, v2) = self.0; + RequestBuilder((v0, v1, v2, value)) + } + + /// Sets the [`body` field](Request#structfield.body) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn body_as_null(self) -> RequestBuilder<(T0, T1, T2, ())> { + self.body(()) + } + } + + impl RequestBuilder<(T0, T1, T2, T3)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Request]. + #[inline] + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) + } + } + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAs<::planus::Offset> + for RequestBuilder<(T0, T1, T2, T3)> + { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) + } + } + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOptional<::planus::Offset> + for RequestBuilder<(T0, T1, T2, T3)> + { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + } + } + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOffset for RequestBuilder<(T0, T1, T2, T3)> + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + let (v0, v1, v2, v3) = &self.0; + Request::create(builder, v0, v1, v2, v3) + } + } + + /// Reference to a deserialized [Request]. + #[derive(Copy, Clone)] + pub struct RequestRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> RequestRef<'a> { + /// Getter for the [`id` field](Request#structfield.id). + #[inline] + pub fn id(&self) -> ::planus::Result { + ::core::result::Result::Ok(self.0.access(0, "Request", "id")?.unwrap_or(0)) + } + + /// Getter for the [`method` field](Request#structfield.method). + #[inline] + pub fn method(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "Request", "method")? + .unwrap_or(self::Method::WorkerClose), + ) + } + + /// Getter for the [`handler_id` field](Request#structfield.handler_id). + #[inline] + pub fn handler_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(2, "Request", "handler_id") + } + + /// Getter for the [`body` field](Request#structfield.body). + #[inline] + pub fn body(&self) -> ::planus::Result<::core::option::Option>> { + self.0.access_union(3, "Request", "body") + } + } + + impl<'a> ::core::fmt::Debug for RequestRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("RequestRef"); + f.field("id", &self.id()); + f.field("method", &self.method()); + f.field("handler_id", &self.handler_id()); + if let ::core::option::Option::Some(field_body) = self.body().transpose() { + f.field("body", &field_body); + } + f.finish() + } + } + + impl<'a> ::core::convert::TryFrom> for Request { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: RequestRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + id: ::core::convert::TryInto::try_into(value.id()?)?, + method: ::core::convert::TryInto::try_into(value.method()?)?, + handler_id: ::core::convert::TryInto::try_into(value.handler_id()?)?, + body: if let ::core::option::Option::Some(body) = value.body()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) + } else { + ::core::option::Option::None + }, + }) + } + } + + impl<'a> ::planus::TableRead<'a> for RequestRef<'a> { + #[inline] + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) + } + } + + impl<'a> ::planus::VectorReadInner<'a> for RequestRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[RequestRef]", + "get", + buffer.offset_from_start, + ) + }) + } + } + + impl ::planus::VectorWrite<::planus::Offset> for Request { + type Value = ::planus::Offset; + const STRIDE: usize = 4; + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) + } + + #[inline] + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } + } + } + + impl<'a> ::planus::ReadAsRoot<'a> for RequestRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[RequestRef]", "read_as_root", 0) + }) + } + } + } + /// The namespace `FBS.Response` + /// + /// Generated from these locations: + /// * File `../worker/fbs/response.fbs` + pub mod response { + /// The union `Body` in the namespace `FBS.Response` + /// + /// Generated from these locations: + /// * Union `Body` in the file `../worker/fbs/response.fbs:12` + #[derive( + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + )] + pub enum Body { + /// The variant `FBS_Worker_DumpResponse` in the union `Body` + FbsWorkerDumpResponse(::planus::alloc::boxed::Box), + + /// The variant `FBS_Worker_ResourceUsageResponse` in the union `Body` + FbsWorkerResourceUsageResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_WebRtcServer_DumpResponse` in the union `Body` + FbsWebRtcServerDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Router_DumpResponse` in the union `Body` + FbsRouterDumpResponse(::planus::alloc::boxed::Box), + + /// The variant `FBS_Transport_ProduceResponse` in the union `Body` + FbsTransportProduceResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Transport_ConsumeResponse` in the union `Body` + FbsTransportConsumeResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Transport_RestartIceResponse` in the union `Body` + FbsTransportRestartIceResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PlainTransport_ConnectResponse` in the union `Body` + FbsPlainTransportConnectResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PlainTransport_DumpResponse` in the union `Body` + FbsPlainTransportDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PlainTransport_GetStatsResponse` in the union `Body` + FbsPlainTransportGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PipeTransport_ConnectResponse` in the union `Body` + FbsPipeTransportConnectResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PipeTransport_DumpResponse` in the union `Body` + FbsPipeTransportDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_PipeTransport_GetStatsResponse` in the union `Body` + FbsPipeTransportGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DirectTransport_DumpResponse` in the union `Body` + FbsDirectTransportDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DirectTransport_GetStatsResponse` in the union `Body` + FbsDirectTransportGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_WebRtcTransport_ConnectResponse` in the union `Body` + FbsWebRtcTransportConnectResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_WebRtcTransport_DumpResponse` in the union `Body` + FbsWebRtcTransportDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_WebRtcTransport_GetStatsResponse` in the union `Body` + FbsWebRtcTransportGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Producer_DumpResponse` in the union `Body` + FbsProducerDumpResponse(::planus::alloc::boxed::Box), + + /// The variant `FBS_Producer_GetStatsResponse` in the union `Body` + FbsProducerGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Consumer_DumpResponse` in the union `Body` + FbsConsumerDumpResponse(::planus::alloc::boxed::Box), + + /// The variant `FBS_Consumer_GetStatsResponse` in the union `Body` + FbsConsumerGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Consumer_SetPreferredLayersResponse` in the union `Body` + FbsConsumerSetPreferredLayersResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_Consumer_SetPriorityResponse` in the union `Body` + FbsConsumerSetPriorityResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataProducer_DumpResponse` in the union `Body` + FbsDataProducerDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataProducer_GetStatsResponse` in the union `Body` + FbsDataProducerGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataConsumer_GetBufferedAmountResponse` in the union `Body` + FbsDataConsumerGetBufferedAmountResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataConsumer_DumpResponse` in the union `Body` + FbsDataConsumerDumpResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataConsumer_GetStatsResponse` in the union `Body` + FbsDataConsumerGetStatsResponse( + ::planus::alloc::boxed::Box, + ), + + /// The variant `FBS_DataConsumer_SetSubchannelsResponse` in the union `Body` + FbsDataConsumerSetSubchannelsResponse( + ::planus::alloc::boxed::Box, + ), + } + + impl Body { + /// Creates a [BodyBuilder] for serializing an instance of this table. + #[inline] + pub fn builder() -> BodyBuilder<::planus::Uninitialized> { + BodyBuilder(::planus::Uninitialized) + } + + #[inline] + pub fn create_fbs_worker_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_worker_resource_usage_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_web_rtc_server_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_router_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_transport_produce_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_transport_consume_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_transport_restart_ice_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_plain_transport_connect_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_plain_transport_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_plain_transport_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_pipe_transport_connect_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_pipe_transport_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_pipe_transport_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_direct_transport_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_direct_transport_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_web_rtc_transport_connect_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_web_rtc_transport_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_web_rtc_transport_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_producer_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(19, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_producer_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(20, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_consumer_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(21, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_consumer_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(22, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_consumer_set_preferred_layers_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(23, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_consumer_set_priority_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(24, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_data_producer_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(25, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_data_producer_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(26, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_data_consumer_get_buffered_amount_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(27, value.prepare(builder).downcast()) + } + + #[inline] + pub fn create_fbs_data_consumer_dump_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(28, value.prepare(builder).downcast()) + } - BodyRef::CloseWebRtcServerRequest(value) => { - Self::CloseWebRtcServerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + #[inline] + pub fn create_fbs_data_consumer_get_stats_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(29, value.prepare(builder).downcast()) + } - BodyRef::CreateRouterRequest(value) => { - Self::CreateRouterRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + #[inline] + pub fn create_fbs_data_consumer_set_subchannels_response( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(30, value.prepare(builder).downcast()) + } + } - BodyRef::CloseRouterRequest(value) => { - Self::CloseRouterRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + impl ::planus::WriteAsUnion for Body { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + match self { + Self::FbsWorkerDumpResponse(value) => { + Self::create_fbs_worker_dump_response(builder, value) } - - BodyRef::CreateWebRtcTransportRequest(value) => { - Self::CreateWebRtcTransportRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsWorkerResourceUsageResponse(value) => { + Self::create_fbs_worker_resource_usage_response(builder, value) } - - BodyRef::CreatePlainTransportRequest(value) => { - Self::CreatePlainTransportRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsWebRtcServerDumpResponse(value) => { + Self::create_fbs_web_rtc_server_dump_response(builder, value) } - - BodyRef::CreatePipeTransportRequest(value) => { - Self::CreatePipeTransportRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsRouterDumpResponse(value) => { + Self::create_fbs_router_dump_response(builder, value) } - - BodyRef::CreateDirectTransportRequest(value) => { - Self::CreateDirectTransportRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsTransportProduceResponse(value) => { + Self::create_fbs_transport_produce_response(builder, value) } - - BodyRef::CreateActiveSpeakerObserverRequest(value) => { - Self::CreateActiveSpeakerObserverRequest( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) + Self::FbsTransportConsumeResponse(value) => { + Self::create_fbs_transport_consume_response(builder, value) } - - BodyRef::CreateAudioLevelObserverRequest(value) => { - Self::CreateAudioLevelObserverRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsTransportRestartIceResponse(value) => { + Self::create_fbs_transport_restart_ice_response(builder, value) } - - BodyRef::CloseTransportRequest(value) => { - Self::CloseTransportRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPlainTransportConnectResponse(value) => { + Self::create_fbs_plain_transport_connect_response(builder, value) } - - BodyRef::CloseRtpObserverRequest(value) => { - Self::CloseRtpObserverRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPlainTransportDumpResponse(value) => { + Self::create_fbs_plain_transport_dump_response(builder, value) } - - BodyRef::SetMaxIncomingBitrateRequest(value) => { - Self::SetMaxIncomingBitrateRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPlainTransportGetStatsResponse(value) => { + Self::create_fbs_plain_transport_get_stats_response(builder, value) } - - BodyRef::SetMaxOutgoingBitrateRequest(value) => { - Self::SetMaxOutgoingBitrateRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPipeTransportConnectResponse(value) => { + Self::create_fbs_pipe_transport_connect_response(builder, value) } - - BodyRef::SetMinOutgoingBitrateRequest(value) => { - Self::SetMinOutgoingBitrateRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPipeTransportDumpResponse(value) => { + Self::create_fbs_pipe_transport_dump_response(builder, value) } - - BodyRef::ProduceRequest(value) => { - Self::ProduceRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsPipeTransportGetStatsResponse(value) => { + Self::create_fbs_pipe_transport_get_stats_response(builder, value) } - - BodyRef::ConsumeRequest(value) => { - Self::ConsumeRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDirectTransportDumpResponse(value) => { + Self::create_fbs_direct_transport_dump_response(builder, value) } - - BodyRef::ProduceDataRequest(value) => { - Self::ProduceDataRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDirectTransportGetStatsResponse(value) => { + Self::create_fbs_direct_transport_get_stats_response(builder, value) } - - BodyRef::ConsumeDataRequest(value) => { - Self::ConsumeDataRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsWebRtcTransportConnectResponse(value) => { + Self::create_fbs_web_rtc_transport_connect_response(builder, value) } - - BodyRef::EnableTraceEventRequest(value) => { - Self::EnableTraceEventRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsWebRtcTransportDumpResponse(value) => { + Self::create_fbs_web_rtc_transport_dump_response(builder, value) } - - BodyRef::CloseProducerRequest(value) => { - Self::CloseProducerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsWebRtcTransportGetStatsResponse(value) => { + Self::create_fbs_web_rtc_transport_get_stats_response(builder, value) } - - BodyRef::CloseConsumerRequest(value) => { - Self::CloseConsumerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsProducerDumpResponse(value) => { + Self::create_fbs_producer_dump_response(builder, value) } - - BodyRef::CloseDataProducerRequest(value) => { - Self::CloseDataProducerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsProducerGetStatsResponse(value) => { + Self::create_fbs_producer_get_stats_response(builder, value) } - - BodyRef::CloseDataConsumerRequest(value) => { - Self::CloseDataConsumerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsConsumerDumpResponse(value) => { + Self::create_fbs_consumer_dump_response(builder, value) } - - BodyRef::PlainTransportConnectRequest(value) => { - Self::PlainTransportConnectRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsConsumerGetStatsResponse(value) => { + Self::create_fbs_consumer_get_stats_response(builder, value) } - - BodyRef::PipeTransportConnectRequest(value) => { - Self::PipeTransportConnectRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsConsumerSetPreferredLayersResponse(value) => { + Self::create_fbs_consumer_set_preferred_layers_response(builder, value) } - - BodyRef::ConnectRequest(value) => { - Self::ConnectRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsConsumerSetPriorityResponse(value) => { + Self::create_fbs_consumer_set_priority_response(builder, value) } - - BodyRef::SetPreferredLayersRequest(value) => { - Self::SetPreferredLayersRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDataProducerDumpResponse(value) => { + Self::create_fbs_data_producer_dump_response(builder, value) } - - BodyRef::SetPriorityRequest(value) => { - Self::SetPriorityRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDataProducerGetStatsResponse(value) => { + Self::create_fbs_data_producer_get_stats_response(builder, value) } - - BodyRef::SetBufferedAmountLowThresholdRequest(value) => { - Self::SetBufferedAmountLowThresholdRequest( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), + Self::FbsDataConsumerGetBufferedAmountResponse(value) => { + Self::create_fbs_data_consumer_get_buffered_amount_response( + builder, value, ) } - - BodyRef::SendRequest(value) => { - Self::SendRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDataConsumerDumpResponse(value) => { + Self::create_fbs_data_consumer_dump_response(builder, value) } - - BodyRef::SetSubchannelsRequest(value) => { - Self::SetSubchannelsRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDataConsumerGetStatsResponse(value) => { + Self::create_fbs_data_consumer_get_stats_response(builder, value) } - - BodyRef::AddProducerRequest(value) => { - Self::AddProducerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) + Self::FbsDataConsumerSetSubchannelsResponse(value) => { + Self::create_fbs_data_consumer_set_subchannels_response(builder, value) } + } + } + } - BodyRef::RemoveProducerRequest(value) => { - Self::RemoveProducerRequest(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - }) + impl ::planus::WriteAsOptionalUnion for Body { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, - ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::UpdateSettingsRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::CreateWebRtcServerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 3 => ::core::result::Result::Ok(Self::CloseWebRtcServerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 4 => ::core::result::Result::Ok(Self::CreateRouterRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 5 => ::core::result::Result::Ok(Self::CloseRouterRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 6 => ::core::result::Result::Ok(Self::CreateWebRtcTransportRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 7 => ::core::result::Result::Ok(Self::CreatePlainTransportRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 8 => ::core::result::Result::Ok(Self::CreatePipeTransportRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 9 => ::core::result::Result::Ok(Self::CreateDirectTransportRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 10 => ::core::result::Result::Ok(Self::CreateActiveSpeakerObserverRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 11 => ::core::result::Result::Ok(Self::CreateAudioLevelObserverRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 12 => ::core::result::Result::Ok(Self::CloseTransportRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 13 => ::core::result::Result::Ok(Self::CloseRtpObserverRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 14 => ::core::result::Result::Ok(Self::SetMaxIncomingBitrateRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 15 => ::core::result::Result::Ok(Self::SetMaxOutgoingBitrateRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 16 => ::core::result::Result::Ok(Self::SetMinOutgoingBitrateRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 17 => ::core::result::Result::Ok(Self::ProduceRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 18 => ::core::result::Result::Ok(Self::ConsumeRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 19 => ::core::result::Result::Ok(Self::ProduceDataRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 20 => ::core::result::Result::Ok(Self::ConsumeDataRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 21 => ::core::result::Result::Ok(Self::EnableTraceEventRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 22 => ::core::result::Result::Ok(Self::CloseProducerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 23 => ::core::result::Result::Ok(Self::CloseConsumerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 24 => ::core::result::Result::Ok(Self::CloseDataProducerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 25 => ::core::result::Result::Ok(Self::CloseDataConsumerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 26 => ::core::result::Result::Ok(Self::PlainTransportConnectRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 27 => ::core::result::Result::Ok(Self::PipeTransportConnectRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 28 => ::core::result::Result::Ok(Self::ConnectRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 29 => ::core::result::Result::Ok(Self::SetPreferredLayersRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 30 => ::core::result::Result::Ok(Self::SetPriorityRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 31 => { - ::core::result::Result::Ok(Self::SetBufferedAmountLowThresholdRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )) - } - 32 => ::core::result::Result::Ok(Self::SendRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 33 => ::core::result::Result::Ok(Self::SetSubchannelsRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 34 => ::core::result::Result::Ok(Self::AddProducerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 35 => ::core::result::Result::Ok(Self::RemoveProducerRequest( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), - } + /// Builder for serializing an instance of the [Body] type. + /// + /// Can be created using the [Body::builder] method. + #[derive(Debug)] + #[must_use] + pub struct BodyBuilder(T); + + impl BodyBuilder<::planus::Uninitialized> { + /// Creates an instance of the [`FBS_Worker_DumpResponse` variant](Body#variant.FbsWorkerDumpResponse). + #[inline] + pub fn fbs_worker_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_Worker_ResourceUsageResponse` variant](Body#variant.FbsWorkerResourceUsageResponse). + #[inline] + pub fn fbs_worker_resource_usage_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_WebRtcServer_DumpResponse` variant](Body#variant.FbsWebRtcServerDumpResponse). + #[inline] + pub fn fbs_web_rtc_server_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_Router_DumpResponse` variant](Body#variant.FbsRouterDumpResponse). + #[inline] + pub fn fbs_router_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_Transport_ProduceResponse` variant](Body#variant.FbsTransportProduceResponse). + #[inline] + pub fn fbs_transport_produce_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_Transport_ConsumeResponse` variant](Body#variant.FbsTransportConsumeResponse). + #[inline] + pub fn fbs_transport_consume_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_Transport_RestartIceResponse` variant](Body#variant.FbsTransportRestartIceResponse). + #[inline] + pub fn fbs_transport_restart_ice_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_PlainTransport_ConnectResponse` variant](Body#variant.FbsPlainTransportConnectResponse). + #[inline] + pub fn fbs_plain_transport_connect_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_PlainTransport_DumpResponse` variant](Body#variant.FbsPlainTransportDumpResponse). + #[inline] + pub fn fbs_plain_transport_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_PlainTransport_GetStatsResponse` variant](Body#variant.FbsPlainTransportGetStatsResponse). + #[inline] + pub fn fbs_plain_transport_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_PipeTransport_ConnectResponse` variant](Body#variant.FbsPipeTransportConnectResponse). + #[inline] + pub fn fbs_pipe_transport_connect_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - /// The table `Request` in the namespace `FBS.Request` - /// - /// Generated from these locations: - /// * Table `Request` in the file `../worker/fbs/request.fbs:121` - #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, - )] - pub struct Request { - /// The field `id` in the table `Request` - pub id: u32, - /// The field `method` in the table `Request` - pub method: self::Method, - /// The field `handler_id` in the table `Request` - pub handler_id: ::planus::alloc::string::String, - /// The field `body` in the table `Request` - pub body: ::core::option::Option, - } + /// Creates an instance of the [`FBS_PipeTransport_DumpResponse` variant](Body#variant.FbsPipeTransportDumpResponse). + #[inline] + pub fn fbs_pipe_transport_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - impl Request { - /// Creates a [RequestBuilder] for serializing an instance of this table. + /// Creates an instance of the [`FBS_PipeTransport_GetStatsResponse` variant](Body#variant.FbsPipeTransportGetStatsResponse). #[inline] - pub fn builder() -> RequestBuilder<()> { - RequestBuilder(()) + pub fn fbs_pipe_transport_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_id: impl ::planus::WriteAsDefault, - field_method: impl ::planus::WriteAsDefault, - field_handler_id: impl ::planus::WriteAs<::planus::Offset>, - field_body: impl ::planus::WriteAsOptionalUnion, - ) -> ::planus::Offset { - let prepared_id = field_id.prepare(builder, &0); - let prepared_method = field_method.prepare(builder, &self::Method::WorkerClose); - let prepared_handler_id = field_handler_id.prepare(builder); - let prepared_body = field_body.prepare(builder); + /// Creates an instance of the [`FBS_DirectTransport_DumpResponse` variant](Body#variant.FbsDirectTransportDumpResponse). + #[inline] + pub fn fbs_direct_transport_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - let mut table_writer: ::planus::table_writer::TableWriter<14> = - ::core::default::Default::default(); - if prepared_id.is_some() { - table_writer.write_entry::(0); - } - table_writer.write_entry::<::planus::Offset>(2); - if prepared_body.is_some() { - table_writer.write_entry::<::planus::Offset>(4); - } - if prepared_method.is_some() { - table_writer.write_entry::(1); - } - if prepared_body.is_some() { - table_writer.write_entry::(3); - } + /// Creates an instance of the [`FBS_DirectTransport_GetStatsResponse` variant](Body#variant.FbsDirectTransportGetStatsResponse). + #[inline] + pub fn fbs_direct_transport_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - unsafe { - table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_id) = prepared_id { - object_writer.write::<_, _, 4>(&prepared_id); - } - object_writer.write::<_, _, 4>(&prepared_handler_id); - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 4>(&prepared_body.offset()); - } - if let ::core::option::Option::Some(prepared_method) = prepared_method { - object_writer.write::<_, _, 1>(&prepared_method); - } - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 1>(&prepared_body.tag()); - } - }); - } - builder.current_offset() + /// Creates an instance of the [`FBS_WebRtcTransport_ConnectResponse` variant](Body#variant.FbsWebRtcTransportConnectResponse). + #[inline] + pub fn fbs_web_rtc_transport_connect_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAs<::planus::Offset> for Request { - type Prepared = ::planus::Offset; + /// Creates an instance of the [`FBS_WebRtcTransport_DumpResponse` variant](Body#variant.FbsWebRtcTransportDumpResponse). + #[inline] + pub fn fbs_web_rtc_transport_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + /// Creates an instance of the [`FBS_WebRtcTransport_GetStatsResponse` variant](Body#variant.FbsWebRtcTransportGetStatsResponse). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + pub fn fbs_web_rtc_transport_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOptional<::planus::Offset> for Request { - type Prepared = ::planus::Offset; + /// Creates an instance of the [`FBS_Producer_DumpResponse` variant](Body#variant.FbsProducerDumpResponse). + #[inline] + pub fn fbs_producer_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + /// Creates an instance of the [`FBS_Producer_GetStatsResponse` variant](Body#variant.FbsProducerGetStatsResponse). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + pub fn fbs_producer_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl ::planus::WriteAsOffset for Request { + /// Creates an instance of the [`FBS_Consumer_DumpResponse` variant](Body#variant.FbsConsumerDumpResponse). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - Request::create(builder, self.id, self.method, &self.handler_id, &self.body) + pub fn fbs_consumer_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - /// Builder for serializing an instance of the [Request] type. - /// - /// Can be created using the [Request::builder] method. - #[derive(Debug)] - #[must_use] - pub struct RequestBuilder(State); + /// Creates an instance of the [`FBS_Consumer_GetStatsResponse` variant](Body#variant.FbsConsumerGetStatsResponse). + #[inline] + pub fn fbs_consumer_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } - impl RequestBuilder<()> { - /// Setter for the [`id` field](Request#structfield.id). + /// Creates an instance of the [`FBS_Consumer_SetPreferredLayersResponse` variant](Body#variant.FbsConsumerSetPreferredLayersResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn id(self, value: T0) -> RequestBuilder<(T0,)> + pub fn fbs_consumer_set_preferred_layers_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<23, T>> where - T0: ::planus::WriteAsDefault, + T: ::planus::WriteAsOffset, { - RequestBuilder((value,)) + BodyBuilder(::planus::Initialized(value)) } - /// Sets the [`id` field](Request#structfield.id) to the default value. + /// Creates an instance of the [`FBS_Consumer_SetPriorityResponse` variant](Body#variant.FbsConsumerSetPriorityResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn id_as_default(self) -> RequestBuilder<(::planus::DefaultValue,)> { - self.id(::planus::DefaultValue) + pub fn fbs_consumer_set_priority_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl RequestBuilder<(T0,)> { - /// Setter for the [`method` field](Request#structfield.method). + /// Creates an instance of the [`FBS_DataProducer_DumpResponse` variant](Body#variant.FbsDataProducerDumpResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn method(self, value: T1) -> RequestBuilder<(T0, T1)> + pub fn fbs_data_producer_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<25, T>> where - T1: ::planus::WriteAsDefault, + T: ::planus::WriteAsOffset, { - let (v0,) = self.0; - RequestBuilder((v0, value)) + BodyBuilder(::planus::Initialized(value)) } - /// Sets the [`method` field](Request#structfield.method) to the default value. + /// Creates an instance of the [`FBS_DataProducer_GetStatsResponse` variant](Body#variant.FbsDataProducerGetStatsResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn method_as_default(self) -> RequestBuilder<(T0, ::planus::DefaultValue)> { - self.method(::planus::DefaultValue) + pub fn fbs_data_producer_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } - } - impl RequestBuilder<(T0, T1)> { - /// Setter for the [`handler_id` field](Request#structfield.handler_id). + /// Creates an instance of the [`FBS_DataConsumer_GetBufferedAmountResponse` variant](Body#variant.FbsDataConsumerGetBufferedAmountResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn handler_id(self, value: T2) -> RequestBuilder<(T0, T1, T2)> + pub fn fbs_data_consumer_get_buffered_amount_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<27, T>> where - T2: ::planus::WriteAs<::planus::Offset>, + T: ::planus::WriteAsOffset, { - let (v0, v1) = self.0; - RequestBuilder((v0, v1, value)) + BodyBuilder(::planus::Initialized(value)) } - } - impl RequestBuilder<(T0, T1, T2)> { - /// Setter for the [`body` field](Request#structfield.body). + /// Creates an instance of the [`FBS_DataConsumer_DumpResponse` variant](Body#variant.FbsDataConsumerDumpResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn body(self, value: T3) -> RequestBuilder<(T0, T1, T2, T3)> + pub fn fbs_data_consumer_dump_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<28, T>> where - T3: ::planus::WriteAsOptionalUnion, + T: ::planus::WriteAsOffset, { - let (v0, v1, v2) = self.0; - RequestBuilder((v0, v1, v2, value)) + BodyBuilder(::planus::Initialized(value)) } - /// Sets the [`body` field](Request#structfield.body) to null. + /// Creates an instance of the [`FBS_DataConsumer_GetStatsResponse` variant](Body#variant.FbsDataConsumerGetStatsResponse). #[inline] - #[allow(clippy::type_complexity)] - pub fn body_as_null(self) -> RequestBuilder<(T0, T1, T2, ())> { - self.body(()) + pub fn fbs_data_consumer_get_stats_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FBS_DataConsumer_SetSubchannelsResponse` variant](Body#variant.FbsDataConsumerSetSubchannelsResponse). + #[inline] + pub fn fbs_data_consumer_set_subchannels_response( + self, + value: T, + ) -> BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { + BodyBuilder(::planus::Initialized(value)) } } - impl RequestBuilder<(T0, T1, T2, T3)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Request]. + impl BodyBuilder<::planus::Initialized> { + /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsUnion, { - ::planus::WriteAsOffset::prepare(&self, builder) + ::planus::WriteAsUnion::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAs<::planus::Offset> - for RequestBuilder<(T0, T1, T2, T3)> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) + } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) + } + } + + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOptional<::planus::Offset> - for RequestBuilder<(T0, T1, T2, T3)> + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; - #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOffset for RequestBuilder<(T0, T1, T2, T3)> + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - Request::create(builder, v0, v1, v2, v3) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) } } - /// Reference to a deserialized [Request]. - #[derive(Copy, Clone)] - pub struct RequestRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> RequestRef<'a> { - /// Getter for the [`id` field](Request#structfield.id). - #[inline] - pub fn id(&self) -> ::planus::Result { - ::core::result::Result::Ok(self.0.access(0, "Request", "id")?.unwrap_or(0)) - } - - /// Getter for the [`method` field](Request#structfield.method). + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn method(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "Request", "method")? - .unwrap_or(self::Method::WorkerClose), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - - /// Getter for the [`handler_id` field](Request#structfield.handler_id). + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn handler_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(2, "Request", "handler_id") + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) } + } - /// Getter for the [`body` field](Request#structfield.body). + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn body(&self) -> ::planus::Result<::core::option::Option>> { - self.0.access_union(3, "Request", "body") + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl<'a> ::core::fmt::Debug for RequestRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("RequestRef"); - f.field("id", &self.id()); - f.field("method", &self.method()); - f.field("handler_id", &self.handler_id()); - if let ::core::option::Option::Some(field_body) = self.body().transpose() { - f.field("body", &field_body); - } - f.finish() + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) } } - impl<'a> ::core::convert::TryFrom> for Request { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: RequestRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - id: ::core::convert::TryInto::try_into(value.id()?)?, - method: ::core::convert::TryInto::try_into(value.method()?)?, - handler_id: ::core::convert::TryInto::try_into(value.handler_id()?)?, - body: if let ::core::option::Option::Some(body) = value.body()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) - } else { - ::core::option::Option::None - }, - }) + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl<'a> ::planus::TableRead<'a> for RequestRef<'a> { + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) } } - impl<'a> ::planus::VectorReadInner<'a> for RequestRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[RequestRef]", - "get", - buffer.offset_from_start, - ) - }) + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl ::planus::VectorWrite<::planus::Offset> for Request { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); - } + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl<'a> ::planus::ReadAsRoot<'a> for RequestRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[RequestRef]", "read_as_root", 0) - }) + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) } } - } - /// The namespace `FBS.Response` - /// - /// Generated from these locations: - /// * File `../worker/fbs/response.fbs` - pub mod response { - /// The union `Body` in the namespace `FBS.Response` - /// - /// Generated from these locations: - /// * Union `Body` in the file `../worker/fbs/response.fbs:12` - #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, - )] - pub enum Body { - /// The variant `FBS_Worker_DumpResponse` in the union `Body` - FbsWorkerDumpResponse(::planus::alloc::boxed::Box), - - /// The variant `FBS_Worker_ResourceUsageResponse` in the union `Body` - FbsWorkerResourceUsageResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_WebRtcServer_DumpResponse` in the union `Body` - FbsWebRtcServerDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Router_DumpResponse` in the union `Body` - FbsRouterDumpResponse(::planus::alloc::boxed::Box), - - /// The variant `FBS_Transport_ProduceResponse` in the union `Body` - FbsTransportProduceResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Transport_ConsumeResponse` in the union `Body` - FbsTransportConsumeResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Transport_RestartIceResponse` in the union `Body` - FbsTransportRestartIceResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PlainTransport_ConnectResponse` in the union `Body` - FbsPlainTransportConnectResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PlainTransport_DumpResponse` in the union `Body` - FbsPlainTransportDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PlainTransport_GetStatsResponse` in the union `Body` - FbsPlainTransportGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PipeTransport_ConnectResponse` in the union `Body` - FbsPipeTransportConnectResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PipeTransport_DumpResponse` in the union `Body` - FbsPipeTransportDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_PipeTransport_GetStatsResponse` in the union `Body` - FbsPipeTransportGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DirectTransport_DumpResponse` in the union `Body` - FbsDirectTransportDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DirectTransport_GetStatsResponse` in the union `Body` - FbsDirectTransportGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_WebRtcTransport_ConnectResponse` in the union `Body` - FbsWebRtcTransportConnectResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_WebRtcTransport_DumpResponse` in the union `Body` - FbsWebRtcTransportDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_WebRtcTransport_GetStatsResponse` in the union `Body` - FbsWebRtcTransportGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Producer_DumpResponse` in the union `Body` - FbsProducerDumpResponse(::planus::alloc::boxed::Box), - - /// The variant `FBS_Producer_GetStatsResponse` in the union `Body` - FbsProducerGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Consumer_DumpResponse` in the union `Body` - FbsConsumerDumpResponse(::planus::alloc::boxed::Box), - - /// The variant `FBS_Consumer_GetStatsResponse` in the union `Body` - FbsConsumerGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Consumer_SetPreferredLayersResponse` in the union `Body` - FbsConsumerSetPreferredLayersResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_Consumer_SetPriorityResponse` in the union `Body` - FbsConsumerSetPriorityResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataProducer_DumpResponse` in the union `Body` - FbsDataProducerDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataProducer_GetStatsResponse` in the union `Body` - FbsDataProducerGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataConsumer_GetBufferedAmountResponse` in the union `Body` - FbsDataConsumerGetBufferedAmountResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataConsumer_DumpResponse` in the union `Body` - FbsDataConsumerDumpResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataConsumer_GetStatsResponse` in the union `Body` - FbsDataConsumerGetStatsResponse( - ::planus::alloc::boxed::Box, - ), - - /// The variant `FBS_DataConsumer_SetSubchannelsResponse` in the union `Body` - FbsDataConsumerSetSubchannelsResponse( - ::planus::alloc::boxed::Box, - ), - } - impl Body { - /// Creates a [BodyBuilder] for serializing an instance of this table. + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn builder() -> BodyBuilder<::planus::Uninitialized> { - BodyBuilder(::planus::Uninitialized) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_worker_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_worker_resource_usage_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_web_rtc_server_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_router_dump_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_transport_produce_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_transport_consume_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_transport_restart_ice_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(19, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<19, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_plain_transport_connect_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_plain_transport_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(20, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<20, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_plain_transport_get_stats_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_pipe_transport_connect_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(21, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<21, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_pipe_transport_dump_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_pipe_transport_get_stats_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(22, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<22, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_direct_transport_dump_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<23, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_direct_transport_get_stats_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(23, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<23, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_web_rtc_transport_connect_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_web_rtc_transport_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(24, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<24, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_web_rtc_transport_get_stats_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<25, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_producer_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(19, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(25, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<25, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_producer_get_stats_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(20, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_consumer_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(21, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(26, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<26, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_consumer_get_stats_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(22, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<27, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_consumer_set_preferred_layers_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(23, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(27, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<27, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_consumer_set_priority_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(24, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<28, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_producer_dump_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(25, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(28, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<28, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_producer_get_stats_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(26, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_consumer_get_buffered_amount_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(27, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(29, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<29, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_consumer_dump_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(28, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } - + } + impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_consumer_get_stats_response( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(29, value.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(30, (self.0).0.prepare(builder).downcast()) } + } + impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<30, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn create_fbs_data_consumer_set_subchannels_response( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(30, value.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for Body { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - match self { - Self::FbsWorkerDumpResponse(value) => { - Self::create_fbs_worker_dump_response(builder, value) + /// Reference to a deserialized [Body]. + #[derive(Copy, Clone, Debug)] + pub enum BodyRef<'a> { + FbsWorkerDumpResponse(super::worker::DumpResponseRef<'a>), + FbsWorkerResourceUsageResponse(super::worker::ResourceUsageResponseRef<'a>), + FbsWebRtcServerDumpResponse(super::web_rtc_server::DumpResponseRef<'a>), + FbsRouterDumpResponse(super::router::DumpResponseRef<'a>), + FbsTransportProduceResponse(super::transport::ProduceResponseRef<'a>), + FbsTransportConsumeResponse(super::transport::ConsumeResponseRef<'a>), + FbsTransportRestartIceResponse(super::transport::RestartIceResponseRef<'a>), + FbsPlainTransportConnectResponse(super::plain_transport::ConnectResponseRef<'a>), + FbsPlainTransportDumpResponse(super::plain_transport::DumpResponseRef<'a>), + FbsPlainTransportGetStatsResponse(super::plain_transport::GetStatsResponseRef<'a>), + FbsPipeTransportConnectResponse(super::pipe_transport::ConnectResponseRef<'a>), + FbsPipeTransportDumpResponse(super::pipe_transport::DumpResponseRef<'a>), + FbsPipeTransportGetStatsResponse(super::pipe_transport::GetStatsResponseRef<'a>), + FbsDirectTransportDumpResponse(super::direct_transport::DumpResponseRef<'a>), + FbsDirectTransportGetStatsResponse( + super::direct_transport::GetStatsResponseRef<'a>, + ), + FbsWebRtcTransportConnectResponse(super::web_rtc_transport::ConnectResponseRef<'a>), + FbsWebRtcTransportDumpResponse(super::web_rtc_transport::DumpResponseRef<'a>), + FbsWebRtcTransportGetStatsResponse( + super::web_rtc_transport::GetStatsResponseRef<'a>, + ), + FbsProducerDumpResponse(super::producer::DumpResponseRef<'a>), + FbsProducerGetStatsResponse(super::producer::GetStatsResponseRef<'a>), + FbsConsumerDumpResponse(super::consumer::DumpResponseRef<'a>), + FbsConsumerGetStatsResponse(super::consumer::GetStatsResponseRef<'a>), + FbsConsumerSetPreferredLayersResponse( + super::consumer::SetPreferredLayersResponseRef<'a>, + ), + FbsConsumerSetPriorityResponse(super::consumer::SetPriorityResponseRef<'a>), + FbsDataProducerDumpResponse(super::data_producer::DumpResponseRef<'a>), + FbsDataProducerGetStatsResponse(super::data_producer::GetStatsResponseRef<'a>), + FbsDataConsumerGetBufferedAmountResponse( + super::data_consumer::GetBufferedAmountResponseRef<'a>, + ), + FbsDataConsumerDumpResponse(super::data_consumer::DumpResponseRef<'a>), + FbsDataConsumerGetStatsResponse(super::data_consumer::GetStatsResponseRef<'a>), + FbsDataConsumerSetSubchannelsResponse( + super::data_consumer::SetSubchannelsResponseRef<'a>, + ), + } + + impl<'a> ::core::convert::TryFrom> for Body { + type Error = ::planus::Error; + + fn try_from(value: BodyRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + BodyRef::FbsWorkerDumpResponse(value) => { + Self::FbsWorkerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsWorkerResourceUsageResponse(value) => { - Self::create_fbs_worker_resource_usage_response(builder, value) + + BodyRef::FbsWorkerResourceUsageResponse(value) => { + Self::FbsWorkerResourceUsageResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsWebRtcServerDumpResponse(value) => { - Self::create_fbs_web_rtc_server_dump_response(builder, value) + + BodyRef::FbsWebRtcServerDumpResponse(value) => { + Self::FbsWebRtcServerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsRouterDumpResponse(value) => { - Self::create_fbs_router_dump_response(builder, value) + + BodyRef::FbsRouterDumpResponse(value) => { + Self::FbsRouterDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsTransportProduceResponse(value) => { - Self::create_fbs_transport_produce_response(builder, value) + + BodyRef::FbsTransportProduceResponse(value) => { + Self::FbsTransportProduceResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsTransportConsumeResponse(value) => { - Self::create_fbs_transport_consume_response(builder, value) + + BodyRef::FbsTransportConsumeResponse(value) => { + Self::FbsTransportConsumeResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsTransportRestartIceResponse(value) => { - Self::create_fbs_transport_restart_ice_response(builder, value) + + BodyRef::FbsTransportRestartIceResponse(value) => { + Self::FbsTransportRestartIceResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsPlainTransportConnectResponse(value) => { - Self::create_fbs_plain_transport_connect_response(builder, value) + + BodyRef::FbsPlainTransportConnectResponse(value) => { + Self::FbsPlainTransportConnectResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsPlainTransportDumpResponse(value) => { - Self::create_fbs_plain_transport_dump_response(builder, value) + + BodyRef::FbsPlainTransportDumpResponse(value) => { + Self::FbsPlainTransportDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsPlainTransportGetStatsResponse(value) => { - Self::create_fbs_plain_transport_get_stats_response(builder, value) + + BodyRef::FbsPlainTransportGetStatsResponse(value) => { + Self::FbsPlainTransportGetStatsResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsPipeTransportConnectResponse(value) => { - Self::create_fbs_pipe_transport_connect_response(builder, value) + + BodyRef::FbsPipeTransportConnectResponse(value) => { + Self::FbsPipeTransportConnectResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsPipeTransportDumpResponse(value) => { - Self::create_fbs_pipe_transport_dump_response(builder, value) + + BodyRef::FbsPipeTransportDumpResponse(value) => { + Self::FbsPipeTransportDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsPipeTransportGetStatsResponse(value) => { - Self::create_fbs_pipe_transport_get_stats_response(builder, value) + + BodyRef::FbsPipeTransportGetStatsResponse(value) => { + Self::FbsPipeTransportGetStatsResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsDirectTransportDumpResponse(value) => { - Self::create_fbs_direct_transport_dump_response(builder, value) + + BodyRef::FbsDirectTransportDumpResponse(value) => { + Self::FbsDirectTransportDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDirectTransportGetStatsResponse(value) => { - Self::create_fbs_direct_transport_get_stats_response(builder, value) + + BodyRef::FbsDirectTransportGetStatsResponse(value) => { + Self::FbsDirectTransportGetStatsResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsWebRtcTransportConnectResponse(value) => { - Self::create_fbs_web_rtc_transport_connect_response(builder, value) + + BodyRef::FbsWebRtcTransportConnectResponse(value) => { + Self::FbsWebRtcTransportConnectResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsWebRtcTransportDumpResponse(value) => { - Self::create_fbs_web_rtc_transport_dump_response(builder, value) + + BodyRef::FbsWebRtcTransportDumpResponse(value) => { + Self::FbsWebRtcTransportDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsWebRtcTransportGetStatsResponse(value) => { - Self::create_fbs_web_rtc_transport_get_stats_response(builder, value) + + BodyRef::FbsWebRtcTransportGetStatsResponse(value) => { + Self::FbsWebRtcTransportGetStatsResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsProducerDumpResponse(value) => { - Self::create_fbs_producer_dump_response(builder, value) + + BodyRef::FbsProducerDumpResponse(value) => { + Self::FbsProducerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsProducerGetStatsResponse(value) => { - Self::create_fbs_producer_get_stats_response(builder, value) + + BodyRef::FbsProducerGetStatsResponse(value) => { + Self::FbsProducerGetStatsResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsConsumerDumpResponse(value) => { - Self::create_fbs_consumer_dump_response(builder, value) + + BodyRef::FbsConsumerDumpResponse(value) => { + Self::FbsConsumerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsConsumerGetStatsResponse(value) => { - Self::create_fbs_consumer_get_stats_response(builder, value) + + BodyRef::FbsConsumerGetStatsResponse(value) => { + Self::FbsConsumerGetStatsResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsConsumerSetPreferredLayersResponse(value) => { - Self::create_fbs_consumer_set_preferred_layers_response(builder, value) + + BodyRef::FbsConsumerSetPreferredLayersResponse(value) => { + Self::FbsConsumerSetPreferredLayersResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - Self::FbsConsumerSetPriorityResponse(value) => { - Self::create_fbs_consumer_set_priority_response(builder, value) + + BodyRef::FbsConsumerSetPriorityResponse(value) => { + Self::FbsConsumerSetPriorityResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDataProducerDumpResponse(value) => { - Self::create_fbs_data_producer_dump_response(builder, value) + + BodyRef::FbsDataProducerDumpResponse(value) => { + Self::FbsDataProducerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDataProducerGetStatsResponse(value) => { - Self::create_fbs_data_producer_get_stats_response(builder, value) + + BodyRef::FbsDataProducerGetStatsResponse(value) => { + Self::FbsDataProducerGetStatsResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDataConsumerGetBufferedAmountResponse(value) => { - Self::create_fbs_data_consumer_get_buffered_amount_response( - builder, value, + + BodyRef::FbsDataConsumerGetBufferedAmountResponse(value) => { + Self::FbsDataConsumerGetBufferedAmountResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), ) } - Self::FbsDataConsumerDumpResponse(value) => { - Self::create_fbs_data_consumer_dump_response(builder, value) + + BodyRef::FbsDataConsumerDumpResponse(value) => { + Self::FbsDataConsumerDumpResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDataConsumerGetStatsResponse(value) => { - Self::create_fbs_data_consumer_get_stats_response(builder, value) + + BodyRef::FbsDataConsumerGetStatsResponse(value) => { + Self::FbsDataConsumerGetStatsResponse(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) } - Self::FbsDataConsumerSetSubchannelsResponse(value) => { - Self::create_fbs_data_consumer_set_subchannels_response(builder, value) + + BodyRef::FbsDataConsumerSetSubchannelsResponse(value) => { + Self::FbsDataConsumerSetSubchannelsResponse( + ::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + ), + ) } - } + }) } } - impl ::planus::WriteAsOptionalUnion for Body { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + field_offset: usize, + tag: u8, + ) -> ::core::result::Result { + match tag { + 1 => ::core::result::Result::Ok(Self::FbsWorkerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::FbsWorkerResourceUsageResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 3 => ::core::result::Result::Ok(Self::FbsWebRtcServerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 4 => ::core::result::Result::Ok(Self::FbsRouterDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 5 => ::core::result::Result::Ok(Self::FbsTransportProduceResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 6 => ::core::result::Result::Ok(Self::FbsTransportConsumeResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 7 => ::core::result::Result::Ok(Self::FbsTransportRestartIceResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 8 => ::core::result::Result::Ok(Self::FbsPlainTransportConnectResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 9 => ::core::result::Result::Ok(Self::FbsPlainTransportDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 10 => ::core::result::Result::Ok(Self::FbsPlainTransportGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 11 => ::core::result::Result::Ok(Self::FbsPipeTransportConnectResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 12 => ::core::result::Result::Ok(Self::FbsPipeTransportDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 13 => ::core::result::Result::Ok(Self::FbsPipeTransportGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 14 => ::core::result::Result::Ok(Self::FbsDirectTransportDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 15 => ::core::result::Result::Ok(Self::FbsDirectTransportGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 16 => ::core::result::Result::Ok(Self::FbsWebRtcTransportConnectResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 17 => ::core::result::Result::Ok(Self::FbsWebRtcTransportDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 18 => ::core::result::Result::Ok(Self::FbsWebRtcTransportGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 19 => ::core::result::Result::Ok(Self::FbsProducerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 20 => ::core::result::Result::Ok(Self::FbsProducerGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 21 => ::core::result::Result::Ok(Self::FbsConsumerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 22 => ::core::result::Result::Ok(Self::FbsConsumerGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 23 => { + ::core::result::Result::Ok(Self::FbsConsumerSetPreferredLayersResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )) + } + 24 => ::core::result::Result::Ok(Self::FbsConsumerSetPriorityResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 25 => ::core::result::Result::Ok(Self::FbsDataProducerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 26 => ::core::result::Result::Ok(Self::FbsDataProducerGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 27 => ::core::result::Result::Ok( + Self::FbsDataConsumerGetBufferedAmountResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + ), + ), + 28 => ::core::result::Result::Ok(Self::FbsDataConsumerDumpResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 29 => ::core::result::Result::Ok(Self::FbsDataConsumerGetStatsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 30 => { + ::core::result::Result::Ok(Self::FbsDataConsumerSetSubchannelsResponse( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )) + } + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), + } } } - /// Builder for serializing an instance of the [Body] type. + /// The table `Response` in the namespace `FBS.Response` /// - /// Can be created using the [Body::builder] method. - #[derive(Debug)] - #[must_use] - pub struct BodyBuilder(T); - - impl BodyBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`FBS_Worker_DumpResponse` variant](Body#variant.FbsWorkerDumpResponse). - #[inline] - pub fn fbs_worker_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_Worker_ResourceUsageResponse` variant](Body#variant.FbsWorkerResourceUsageResponse). - #[inline] - pub fn fbs_worker_resource_usage_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_WebRtcServer_DumpResponse` variant](Body#variant.FbsWebRtcServerDumpResponse). - #[inline] - pub fn fbs_web_rtc_server_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_Router_DumpResponse` variant](Body#variant.FbsRouterDumpResponse). - #[inline] - pub fn fbs_router_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_Transport_ProduceResponse` variant](Body#variant.FbsTransportProduceResponse). - #[inline] - pub fn fbs_transport_produce_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_Transport_ConsumeResponse` variant](Body#variant.FbsTransportConsumeResponse). - #[inline] - pub fn fbs_transport_consume_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_Transport_RestartIceResponse` variant](Body#variant.FbsTransportRestartIceResponse). - #[inline] - pub fn fbs_transport_restart_ice_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_PlainTransport_ConnectResponse` variant](Body#variant.FbsPlainTransportConnectResponse). - #[inline] - pub fn fbs_plain_transport_connect_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } - - /// Creates an instance of the [`FBS_PlainTransport_DumpResponse` variant](Body#variant.FbsPlainTransportDumpResponse). - #[inline] - pub fn fbs_plain_transport_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// Generated from these locations: + /// * Table `Response` in the file `../worker/fbs/response.fbs:45` + #[derive( + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + )] + pub struct Response { + /// The field `id` in the table `Response` + pub id: u32, + /// The field `accepted` in the table `Response` + pub accepted: bool, + /// The field `body` in the table `Response` + pub body: ::core::option::Option, + /// The field `error` in the table `Response` + pub error: ::core::option::Option<::planus::alloc::string::String>, + /// The field `reason` in the table `Response` + pub reason: ::core::option::Option<::planus::alloc::string::String>, + } - /// Creates an instance of the [`FBS_PlainTransport_GetStatsResponse` variant](Body#variant.FbsPlainTransportGetStatsResponse). - #[inline] - pub fn fbs_plain_transport_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Response { + fn default() -> Self { + Self { + id: 0, + accepted: false, + body: ::core::default::Default::default(), + error: ::core::default::Default::default(), + reason: ::core::default::Default::default(), + } } + } - /// Creates an instance of the [`FBS_PipeTransport_ConnectResponse` variant](Body#variant.FbsPipeTransportConnectResponse). + impl Response { + /// Creates a [ResponseBuilder] for serializing an instance of this table. #[inline] - pub fn fbs_pipe_transport_connect_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + pub fn builder() -> ResponseBuilder<()> { + ResponseBuilder(()) } - /// Creates an instance of the [`FBS_PipeTransport_DumpResponse` variant](Body#variant.FbsPipeTransportDumpResponse). - #[inline] - pub fn fbs_pipe_transport_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_id: impl ::planus::WriteAsDefault, + field_accepted: impl ::planus::WriteAsDefault, + field_body: impl ::planus::WriteAsOptionalUnion, + field_error: impl ::planus::WriteAsOptional< + ::planus::Offset<::core::primitive::str>, + >, + field_reason: impl ::planus::WriteAsOptional< + ::planus::Offset<::core::primitive::str>, + >, + ) -> ::planus::Offset { + let prepared_id = field_id.prepare(builder, &0); + let prepared_accepted = field_accepted.prepare(builder, &false); + let prepared_body = field_body.prepare(builder); + let prepared_error = field_error.prepare(builder); + let prepared_reason = field_reason.prepare(builder); - /// Creates an instance of the [`FBS_PipeTransport_GetStatsResponse` variant](Body#variant.FbsPipeTransportGetStatsResponse). - #[inline] - pub fn fbs_pipe_transport_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + let mut table_writer: ::planus::table_writer::TableWriter<16> = + ::core::default::Default::default(); + if prepared_id.is_some() { + table_writer.write_entry::(0); + } + if prepared_body.is_some() { + table_writer.write_entry::<::planus::Offset>(3); + } + if prepared_error.is_some() { + table_writer.write_entry::<::planus::Offset>(4); + } + if prepared_reason.is_some() { + table_writer.write_entry::<::planus::Offset>(5); + } + if prepared_accepted.is_some() { + table_writer.write_entry::(1); + } + if prepared_body.is_some() { + table_writer.write_entry::(2); + } - /// Creates an instance of the [`FBS_DirectTransport_DumpResponse` variant](Body#variant.FbsDirectTransportDumpResponse). - #[inline] - pub fn fbs_direct_transport_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_id) = prepared_id { + object_writer.write::<_, _, 4>(&prepared_id); + } + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 4>(&prepared_body.offset()); + } + if let ::core::option::Option::Some(prepared_error) = prepared_error { + object_writer.write::<_, _, 4>(&prepared_error); + } + if let ::core::option::Option::Some(prepared_reason) = prepared_reason { + object_writer.write::<_, _, 4>(&prepared_reason); + } + if let ::core::option::Option::Some(prepared_accepted) = + prepared_accepted + { + object_writer.write::<_, _, 1>(&prepared_accepted); + } + if let ::core::option::Option::Some(prepared_body) = prepared_body { + object_writer.write::<_, _, 1>(&prepared_body.tag()); + } + }); + } + builder.current_offset() } + } - /// Creates an instance of the [`FBS_DirectTransport_GetStatsResponse` variant](Body#variant.FbsDirectTransportGetStatsResponse). - #[inline] - pub fn fbs_direct_transport_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + impl ::planus::WriteAs<::planus::Offset> for Response { + type Prepared = ::planus::Offset; - /// Creates an instance of the [`FBS_WebRtcTransport_ConnectResponse` variant](Body#variant.FbsWebRtcTransportConnectResponse). #[inline] - pub fn fbs_web_rtc_transport_connect_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } - /// Creates an instance of the [`FBS_WebRtcTransport_DumpResponse` variant](Body#variant.FbsWebRtcTransportDumpResponse). - #[inline] - pub fn fbs_web_rtc_transport_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + impl ::planus::WriteAsOptional<::planus::Offset> for Response { + type Prepared = ::planus::Offset; - /// Creates an instance of the [`FBS_WebRtcTransport_GetStatsResponse` variant](Body#variant.FbsWebRtcTransportGetStatsResponse). #[inline] - pub fn fbs_web_rtc_transport_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Creates an instance of the [`FBS_Producer_DumpResponse` variant](Body#variant.FbsProducerDumpResponse). + impl ::planus::WriteAsOffset for Response { #[inline] - pub fn fbs_producer_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + Response::create( + builder, + self.id, + self.accepted, + &self.body, + &self.error, + &self.reason, + ) } + } - /// Creates an instance of the [`FBS_Producer_GetStatsResponse` variant](Body#variant.FbsProducerGetStatsResponse). - #[inline] - pub fn fbs_producer_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) - } + /// Builder for serializing an instance of the [Response] type. + /// + /// Can be created using the [Response::builder] method. + #[derive(Debug)] + #[must_use] + pub struct ResponseBuilder(State); - /// Creates an instance of the [`FBS_Consumer_DumpResponse` variant](Body#variant.FbsConsumerDumpResponse). + impl ResponseBuilder<()> { + /// Setter for the [`id` field](Response#structfield.id). #[inline] - pub fn fbs_consumer_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<21, T>> + #[allow(clippy::type_complexity)] + pub fn id(self, value: T0) -> ResponseBuilder<(T0,)> where - T: ::planus::WriteAsOffset, + T0: ::planus::WriteAsDefault, { - BodyBuilder(::planus::Initialized(value)) + ResponseBuilder((value,)) } - /// Creates an instance of the [`FBS_Consumer_GetStatsResponse` variant](Body#variant.FbsConsumerGetStatsResponse). + /// Sets the [`id` field](Response#structfield.id) to the default value. #[inline] - pub fn fbs_consumer_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::type_complexity)] + pub fn id_as_default(self) -> ResponseBuilder<(::planus::DefaultValue,)> { + self.id(::planus::DefaultValue) } + } - /// Creates an instance of the [`FBS_Consumer_SetPreferredLayersResponse` variant](Body#variant.FbsConsumerSetPreferredLayersResponse). + impl ResponseBuilder<(T0,)> { + /// Setter for the [`accepted` field](Response#structfield.accepted). #[inline] - pub fn fbs_consumer_set_preferred_layers_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<23, T>> + #[allow(clippy::type_complexity)] + pub fn accepted(self, value: T1) -> ResponseBuilder<(T0, T1)> where - T: ::planus::WriteAsOffset, + T1: ::planus::WriteAsDefault, { - BodyBuilder(::planus::Initialized(value)) + let (v0,) = self.0; + ResponseBuilder((v0, value)) } - /// Creates an instance of the [`FBS_Consumer_SetPriorityResponse` variant](Body#variant.FbsConsumerSetPriorityResponse). + /// Sets the [`accepted` field](Response#structfield.accepted) to the default value. #[inline] - pub fn fbs_consumer_set_priority_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::type_complexity)] + pub fn accepted_as_default(self) -> ResponseBuilder<(T0, ::planus::DefaultValue)> { + self.accepted(::planus::DefaultValue) } + } - /// Creates an instance of the [`FBS_DataProducer_DumpResponse` variant](Body#variant.FbsDataProducerDumpResponse). + impl ResponseBuilder<(T0, T1)> { + /// Setter for the [`body` field](Response#structfield.body). #[inline] - pub fn fbs_data_producer_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<25, T>> + #[allow(clippy::type_complexity)] + pub fn body(self, value: T2) -> ResponseBuilder<(T0, T1, T2)> where - T: ::planus::WriteAsOffset, + T2: ::planus::WriteAsOptionalUnion, { - BodyBuilder(::planus::Initialized(value)) + let (v0, v1) = self.0; + ResponseBuilder((v0, v1, value)) } - /// Creates an instance of the [`FBS_DataProducer_GetStatsResponse` variant](Body#variant.FbsDataProducerGetStatsResponse). + /// Sets the [`body` field](Response#structfield.body) to null. #[inline] - pub fn fbs_data_producer_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::type_complexity)] + pub fn body_as_null(self) -> ResponseBuilder<(T0, T1, ())> { + self.body(()) } + } - /// Creates an instance of the [`FBS_DataConsumer_GetBufferedAmountResponse` variant](Body#variant.FbsDataConsumerGetBufferedAmountResponse). + impl ResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`error` field](Response#structfield.error). #[inline] - pub fn fbs_data_consumer_get_buffered_amount_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<27, T>> + #[allow(clippy::type_complexity)] + pub fn error(self, value: T3) -> ResponseBuilder<(T0, T1, T2, T3)> where - T: ::planus::WriteAsOffset, + T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, { - BodyBuilder(::planus::Initialized(value)) + let (v0, v1, v2) = self.0; + ResponseBuilder((v0, v1, v2, value)) } - /// Creates an instance of the [`FBS_DataConsumer_DumpResponse` variant](Body#variant.FbsDataConsumerDumpResponse). + /// Sets the [`error` field](Response#structfield.error) to null. #[inline] - pub fn fbs_data_consumer_dump_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::type_complexity)] + pub fn error_as_null(self) -> ResponseBuilder<(T0, T1, T2, ())> { + self.error(()) } + } - /// Creates an instance of the [`FBS_DataConsumer_GetStatsResponse` variant](Body#variant.FbsDataConsumerGetStatsResponse). + impl ResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`reason` field](Response#structfield.reason). #[inline] - pub fn fbs_data_consumer_get_stats_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<29, T>> + #[allow(clippy::type_complexity)] + pub fn reason(self, value: T4) -> ResponseBuilder<(T0, T1, T2, T3, T4)> where - T: ::planus::WriteAsOffset, + T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, { - BodyBuilder(::planus::Initialized(value)) + let (v0, v1, v2, v3) = self.0; + ResponseBuilder((v0, v1, v2, v3, value)) } - /// Creates an instance of the [`FBS_DataConsumer_SetSubchannelsResponse` variant](Body#variant.FbsDataConsumerSetSubchannelsResponse). + /// Sets the [`reason` field](Response#structfield.reason) to null. #[inline] - pub fn fbs_data_consumer_set_subchannels_response( - self, - value: T, - ) -> BodyBuilder<::planus::Initialized<30, T>> - where - T: ::planus::WriteAsOffset, - { - BodyBuilder(::planus::Initialized(value)) + #[allow(clippy::type_complexity)] + pub fn reason_as_null(self) -> ResponseBuilder<(T0, T1, T2, T3, ())> { + self.reason(()) } } - impl BodyBuilder<::planus::Initialized> { - /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Body]. + impl ResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Response]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset where - Self: ::planus::WriteAsUnion, + Self: ::planus::WriteAsOffset, { - ::planus::WriteAsUnion::prepare(&self, builder) + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + > ::planus::WriteAs<::planus::Offset> + for ResponseBuilder<(T0, T1, T2, T3, T4)> { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + > ::planus::WriteAsOptional<::planus::Offset> + for ResponseBuilder<(T0, T1, T2, T3, T4)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptionalUnion, + T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + > ::planus::WriteAsOffset for ResponseBuilder<(T0, T1, T2, T3, T4)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + let (v0, v1, v2, v3, v4) = &self.0; + Response::create(builder, v0, v1, v2, v3, v4) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { + /// Reference to a deserialized [Response]. + #[derive(Copy, Clone)] + pub struct ResponseRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> ResponseRef<'a> { + /// Getter for the [`id` field](Response#structfield.id). #[inline] - fn prepare( + pub fn id(&self) -> ::planus::Result { + ::core::result::Result::Ok(self.0.access(0, "Response", "id")?.unwrap_or(0)) + } + + /// Getter for the [`accepted` field](Response#structfield.accepted). + #[inline] + pub fn accepted(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0.access(1, "Response", "accepted")?.unwrap_or(false), + ) + } + + /// Getter for the [`body` field](Response#structfield.body). + #[inline] + pub fn body(&self) -> ::planus::Result<::core::option::Option>> { + self.0.access_union(2, "Response", "body") + } + + /// Getter for the [`error` field](Response#structfield.error). + #[inline] + pub fn error( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> + { + self.0.access(4, "Response", "error") + } + + /// Getter for the [`reason` field](Response#structfield.reason). + #[inline] + pub fn reason( + &self, + ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> + { + self.0.access(5, "Response", "reason") } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'a> ::core::fmt::Debug for ResponseRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("ResponseRef"); + f.field("id", &self.id()); + f.field("accepted", &self.accepted()); + if let ::core::option::Option::Some(field_body) = self.body().transpose() { + f.field("body", &field_body); + } + if let ::core::option::Option::Some(field_error) = self.error().transpose() { + f.field("error", &field_error); + } + if let ::core::option::Option::Some(field_reason) = self.reason().transpose() { + f.field("reason", &field_reason); + } + f.finish() + } + } + + impl<'a> ::core::convert::TryFrom> for Response { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: ResponseRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + id: ::core::convert::TryInto::try_into(value.id()?)?, + accepted: ::core::convert::TryInto::try_into(value.accepted()?)?, + body: if let ::core::option::Option::Some(body) = value.body()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) + } else { + ::core::option::Option::None + }, + error: if let ::core::option::Option::Some(error) = value.error()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(error)?) + } else { + ::core::option::Option::None + }, + reason: if let ::core::option::Option::Some(reason) = value.reason()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + reason, + )?) + } else { + ::core::option::Option::None + }, + }) + } + } + + impl<'a> ::planus::TableRead<'a> for ResponseRef<'a> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { + impl<'a> ::planus::VectorReadInner<'a> for ResponseRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[ResponseRef]", + "get", + buffer.offset_from_start, + ) + }) + } + } + + impl ::planus::VectorWrite<::planus::Offset> for Response { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) + } + + #[inline] + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'a> ::planus::ReadAsRoot<'a> for ResponseRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[ResponseRef]", "read_as_root", 0) + }) + } + } + } + /// The namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * File `../worker/fbs/worker.fbs` + pub mod worker { + /// The table `ChannelMessageHandlers` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `ChannelMessageHandlers` in the file `../worker/fbs/worker.fbs:5` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct ChannelMessageHandlers { + /// The field `channel_request_handlers` in the table `ChannelMessageHandlers` + pub channel_request_handlers: + ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `channel_notification_handlers` in the table `ChannelMessageHandlers` + pub channel_notification_handlers: + ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + } + + impl ChannelMessageHandlers { + /// Creates a [ChannelMessageHandlersBuilder] for serializing an instance of this table. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) + pub fn builder() -> ChannelMessageHandlersBuilder<()> { + ChannelMessageHandlersBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_channel_request_handlers: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_channel_notification_handlers: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + ) -> ::planus::Offset { + let prepared_channel_request_handlers = + field_channel_request_handlers.prepare(builder); + let prepared_channel_notification_handlers = + field_channel_notification_handlers.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<8> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_channel_request_handlers); + object_writer.write::<_, _, 4>(&prepared_channel_notification_handlers); + }); + } + builder.current_offset() } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAs<::planus::Offset> for ChannelMessageHandlers { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, + + impl ::planus::WriteAsOptional<::planus::Offset> + for ChannelMessageHandlers { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(5, (self.0).0.prepare(builder).downcast()) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> + { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<5, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOffset for ChannelMessageHandlers { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + ChannelMessageHandlers::create( + builder, + &self.channel_request_handlers, + &self.channel_notification_handlers, + ) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Builder for serializing an instance of the [ChannelMessageHandlers] type. + /// + /// Can be created using the [ChannelMessageHandlers::builder] method. + #[derive(Debug)] + #[must_use] + pub struct ChannelMessageHandlersBuilder(State); + + impl ChannelMessageHandlersBuilder<()> { + /// Setter for the [`channel_request_handlers` field](ChannelMessageHandlers#structfield.channel_request_handlers). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(6, (self.0).0.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn channel_request_handlers( + self, + value: T0, + ) -> ChannelMessageHandlersBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + ChannelMessageHandlersBuilder((value,)) + } + } + + impl ChannelMessageHandlersBuilder<(T0,)> { + /// Setter for the [`channel_notification_handlers` field](ChannelMessageHandlers#structfield.channel_notification_handlers). + #[inline] + #[allow(clippy::type_complexity)] + pub fn channel_notification_handlers( + self, + value: T1, + ) -> ChannelMessageHandlersBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0,) = self.0; + ChannelMessageHandlersBuilder((v0, value)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<6, T>> - where - T: ::planus::WriteAsOffset, - { + impl ChannelMessageHandlersBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ChannelMessageHandlers]. #[inline] - fn prepare( - &self, + pub fn finish( + self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(7, (self.0).0.prepare(builder).downcast()) + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<7, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAs<::planus::Offset> + for ChannelMessageHandlersBuilder<(T0, T1)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(8, (self.0).0.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<8, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOptional<::planus::Offset> + for ChannelMessageHandlersBuilder<(T0, T1)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(9, (self.0).0.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> + { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<9, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOffset + for ChannelMessageHandlersBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + ChannelMessageHandlers::create(builder, v0, v1) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Reference to a deserialized [ChannelMessageHandlers]. + #[derive(Copy, Clone)] + pub struct ChannelMessageHandlersRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> ChannelMessageHandlersRef<'a> { + /// Getter for the [`channel_request_handlers` field](ChannelMessageHandlers#structfield.channel_request_handlers). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(10, (self.0).0.prepare(builder).downcast()) + pub fn channel_request_handlers( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0 + .access_required(0, "ChannelMessageHandlers", "channel_request_handlers") } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<10, T>> - where - T: ::planus::WriteAsOffset, - { + /// Getter for the [`channel_notification_handlers` field](ChannelMessageHandlers#structfield.channel_notification_handlers). #[inline] - fn prepare( + pub fn channel_notification_handlers( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0.access_required( + 1, + "ChannelMessageHandlers", + "channel_notification_handlers", + ) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(11, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::core::fmt::Debug for ChannelMessageHandlersRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("ChannelMessageHandlersRef"); + f.field("channel_request_handlers", &self.channel_request_handlers()); + f.field( + "channel_notification_handlers", + &self.channel_notification_handlers(), + ); + f.finish() } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<11, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::core::convert::TryFrom> for ChannelMessageHandlers { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: ChannelMessageHandlersRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + channel_request_handlers: value + .channel_request_handlers()? + .to_vec_result()?, + channel_notification_handlers: value + .channel_notification_handlers()? + .to_vec_result()?, + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'a> ::planus::TableRead<'a> for ChannelMessageHandlersRef<'a> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(12, (self.0).0.prepare(builder).downcast()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<12, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::planus::VectorReadInner<'a> for ChannelMessageHandlersRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[ChannelMessageHandlersRef]", + "get", + buffer.offset_from_start, + ) + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::VectorWrite<::planus::Offset> for ChannelMessageHandlers { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(13, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<13, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(14, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::planus::ReadAsRoot<'a> for ChannelMessageHandlersRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location( + "[ChannelMessageHandlersRef]", + "read_as_root", + 0, + ) + }) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<14, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } + /// The table `DumpResponse` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `DumpResponse` in the file `../worker/fbs/worker.fbs:10` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct DumpResponse { + /// The field `pid` in the table `DumpResponse` + pub pid: u32, + /// The field `web_rtc_server_ids` in the table `DumpResponse` + pub web_rtc_server_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `router_ids` in the table `DumpResponse` + pub router_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `channel_message_handlers` in the table `DumpResponse` + pub channel_message_handlers: + ::planus::alloc::boxed::Box, } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { + + impl DumpResponse { + /// Creates a [DumpResponseBuilder] for serializing an instance of this table. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(15, (self.0).0.prepare(builder).downcast()) + pub fn builder() -> DumpResponseBuilder<()> { + DumpResponseBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_pid: impl ::planus::WriteAsDefault, + field_web_rtc_server_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_router_ids: impl ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + field_channel_message_handlers: impl ::planus::WriteAs< + ::planus::Offset, + >, + ) -> ::planus::Offset { + let prepared_pid = field_pid.prepare(builder, &0); + let prepared_web_rtc_server_ids = field_web_rtc_server_ids.prepare(builder); + let prepared_router_ids = field_router_ids.prepare(builder); + let prepared_channel_message_handlers = + field_channel_message_handlers.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<12> = + ::core::default::Default::default(); + if prepared_pid.is_some() { + table_writer.write_entry::(0); + } + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(2); + table_writer.write_entry::<::planus::Offset>(3); + + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_pid) = prepared_pid { + object_writer.write::<_, _, 4>(&prepared_pid); + } + object_writer.write::<_, _, 4>(&prepared_web_rtc_server_ids); + object_writer.write::<_, _, 4>(&prepared_router_ids); + object_writer.write::<_, _, 4>(&prepared_channel_message_handlers); + }); + } + builder.current_offset() } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<15, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(16, (self.0).0.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<16, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(17, (self.0).0.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<17, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOffset for DumpResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + DumpResponse::create( + builder, + self.pid, + &self.web_rtc_server_ids, + &self.router_ids, + &self.channel_message_handlers, + ) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Builder for serializing an instance of the [DumpResponse] type. + /// + /// Can be created using the [DumpResponse::builder] method. + #[derive(Debug)] + #[must_use] + pub struct DumpResponseBuilder(State); + + impl DumpResponseBuilder<()> { + /// Setter for the [`pid` field](DumpResponse#structfield.pid). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(18, (self.0).0.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn pid(self, value: T0) -> DumpResponseBuilder<(T0,)> + where + T0: ::planus::WriteAsDefault, + { + DumpResponseBuilder((value,)) + } + + /// Sets the [`pid` field](DumpResponse#structfield.pid) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn pid_as_default(self) -> DumpResponseBuilder<(::planus::DefaultValue,)> { + self.pid(::planus::DefaultValue) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<18, T>> - where - T: ::planus::WriteAsOffset, - { + impl DumpResponseBuilder<(T0,)> { + /// Setter for the [`web_rtc_server_ids` field](DumpResponse#structfield.web_rtc_server_ids). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + #[allow(clippy::type_complexity)] + pub fn web_rtc_server_ids(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0,) = self.0; + DumpResponseBuilder((v0, value)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { + + impl DumpResponseBuilder<(T0, T1)> { + /// Setter for the [`router_ids` field](DumpResponse#structfield.router_ids). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(19, (self.0).0.prepare(builder).downcast()) + #[allow(clippy::type_complexity)] + pub fn router_ids(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0, v1) = self.0; + DumpResponseBuilder((v0, v1, value)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<19, T>> - where - T: ::planus::WriteAsOffset, - { + impl DumpResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`channel_message_handlers` field](DumpResponse#structfield.channel_message_handlers). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + #[allow(clippy::type_complexity)] + pub fn channel_message_handlers( + self, + value: T3, + ) -> DumpResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAs<::planus::Offset>, + { + let (v0, v1, v2) = self.0; + DumpResponseBuilder((v0, v1, v2, value)) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, - { + + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(20, (self.0).0.prepare(builder).downcast()) + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<20, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<21, T>> - where - T: ::planus::WriteAsOffset, + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3)> { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(21, (self.0).0.prepare(builder).downcast()) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<21, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset for DumpResponseBuilder<(T0, T1, T2, T3)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + let (v0, v1, v2, v3) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Reference to a deserialized [DumpResponse]. + #[derive(Copy, Clone)] + pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> DumpResponseRef<'a> { + /// Getter for the [`pid` field](DumpResponse#structfield.pid). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(22, (self.0).0.prepare(builder).downcast()) + pub fn pid(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0.access(0, "DumpResponse", "pid")?.unwrap_or(0), + ) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<22, T>> - where - T: ::planus::WriteAsOffset, - { + /// Getter for the [`web_rtc_server_ids` field](DumpResponse#structfield.web_rtc_server_ids). #[inline] - fn prepare( + pub fn web_rtc_server_ids( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0 + .access_required(1, "DumpResponse", "web_rtc_server_ids") } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<23, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Getter for the [`router_ids` field](DumpResponse#structfield.router_ids). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(23, (self.0).0.prepare(builder).downcast()) + pub fn router_ids( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0.access_required(2, "DumpResponse", "router_ids") } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<23, T>> - where - T: ::planus::WriteAsOffset, - { + /// Getter for the [`channel_message_handlers` field](DumpResponse#structfield.channel_message_handlers). #[inline] - fn prepare( + pub fn channel_message_handlers( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Result> { + self.0 + .access_required(3, "DumpResponse", "channel_message_handlers") } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(24, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("DumpResponseRef"); + f.field("pid", &self.pid()); + f.field("web_rtc_server_ids", &self.web_rtc_server_ids()); + f.field("router_ids", &self.router_ids()); + f.field("channel_message_handlers", &self.channel_message_handlers()); + f.finish() } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<24, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::core::convert::TryFrom> for DumpResponse { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + pid: ::core::convert::TryInto::try_into(value.pid()?)?, + web_rtc_server_ids: value.web_rtc_server_ids()?.to_vec_result()?, + router_ids: value.router_ids()?.to_vec_result()?, + channel_message_handlers: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.channel_message_handlers()?)?, + ), + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<25, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(25, (self.0).0.prepare(builder).downcast()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<25, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[DumpResponseRef]", + "get", + buffer.offset_from_start, + ) + }) } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(26, (self.0).0.prepare(builder).downcast()) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<26, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<27, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(27, (self.0).0.prepare(builder).downcast()) + + impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + }) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<27, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + /// The table `ResourceUsageResponse` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `ResourceUsageResponse` in the file `../worker/fbs/worker.fbs:17` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct ResourceUsageResponse { + /// The field `ru_utime` in the table `ResourceUsageResponse` + pub ru_utime: u64, + /// The field `ru_stime` in the table `ResourceUsageResponse` + pub ru_stime: u64, + /// The field `ru_maxrss` in the table `ResourceUsageResponse` + pub ru_maxrss: u64, + /// The field `ru_ixrss` in the table `ResourceUsageResponse` + pub ru_ixrss: u64, + /// The field `ru_idrss` in the table `ResourceUsageResponse` + pub ru_idrss: u64, + /// The field `ru_isrss` in the table `ResourceUsageResponse` + pub ru_isrss: u64, + /// The field `ru_minflt` in the table `ResourceUsageResponse` + pub ru_minflt: u64, + /// The field `ru_majflt` in the table `ResourceUsageResponse` + pub ru_majflt: u64, + /// The field `ru_nswap` in the table `ResourceUsageResponse` + pub ru_nswap: u64, + /// The field `ru_inblock` in the table `ResourceUsageResponse` + pub ru_inblock: u64, + /// The field `ru_oublock` in the table `ResourceUsageResponse` + pub ru_oublock: u64, + /// The field `ru_msgsnd` in the table `ResourceUsageResponse` + pub ru_msgsnd: u64, + /// The field `ru_msgrcv` in the table `ResourceUsageResponse` + pub ru_msgrcv: u64, + /// The field `ru_nsignals` in the table `ResourceUsageResponse` + pub ru_nsignals: u64, + /// The field `ru_nvcsw` in the table `ResourceUsageResponse` + pub ru_nvcsw: u64, + /// The field `ru_nivcsw` in the table `ResourceUsageResponse` + pub ru_nivcsw: u64, + } + + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for ResourceUsageResponse { + fn default() -> Self { + Self { + ru_utime: 0, + ru_stime: 0, + ru_maxrss: 0, + ru_ixrss: 0, + ru_idrss: 0, + ru_isrss: 0, + ru_minflt: 0, + ru_majflt: 0, + ru_nswap: 0, + ru_inblock: 0, + ru_oublock: 0, + ru_msgsnd: 0, + ru_msgrcv: 0, + ru_nsignals: 0, + ru_nvcsw: 0, + ru_nivcsw: 0, + } } } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { + + impl ResourceUsageResponse { + /// Creates a [ResourceUsageResponseBuilder] for serializing an instance of this table. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(28, (self.0).0.prepare(builder).downcast()) + pub fn builder() -> ResourceUsageResponseBuilder<()> { + ResourceUsageResponseBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_ru_utime: impl ::planus::WriteAsDefault, + field_ru_stime: impl ::planus::WriteAsDefault, + field_ru_maxrss: impl ::planus::WriteAsDefault, + field_ru_ixrss: impl ::planus::WriteAsDefault, + field_ru_idrss: impl ::planus::WriteAsDefault, + field_ru_isrss: impl ::planus::WriteAsDefault, + field_ru_minflt: impl ::planus::WriteAsDefault, + field_ru_majflt: impl ::planus::WriteAsDefault, + field_ru_nswap: impl ::planus::WriteAsDefault, + field_ru_inblock: impl ::planus::WriteAsDefault, + field_ru_oublock: impl ::planus::WriteAsDefault, + field_ru_msgsnd: impl ::planus::WriteAsDefault, + field_ru_msgrcv: impl ::planus::WriteAsDefault, + field_ru_nsignals: impl ::planus::WriteAsDefault, + field_ru_nvcsw: impl ::planus::WriteAsDefault, + field_ru_nivcsw: impl ::planus::WriteAsDefault, + ) -> ::planus::Offset { + let prepared_ru_utime = field_ru_utime.prepare(builder, &0); + let prepared_ru_stime = field_ru_stime.prepare(builder, &0); + let prepared_ru_maxrss = field_ru_maxrss.prepare(builder, &0); + let prepared_ru_ixrss = field_ru_ixrss.prepare(builder, &0); + let prepared_ru_idrss = field_ru_idrss.prepare(builder, &0); + let prepared_ru_isrss = field_ru_isrss.prepare(builder, &0); + let prepared_ru_minflt = field_ru_minflt.prepare(builder, &0); + let prepared_ru_majflt = field_ru_majflt.prepare(builder, &0); + let prepared_ru_nswap = field_ru_nswap.prepare(builder, &0); + let prepared_ru_inblock = field_ru_inblock.prepare(builder, &0); + let prepared_ru_oublock = field_ru_oublock.prepare(builder, &0); + let prepared_ru_msgsnd = field_ru_msgsnd.prepare(builder, &0); + let prepared_ru_msgrcv = field_ru_msgrcv.prepare(builder, &0); + let prepared_ru_nsignals = field_ru_nsignals.prepare(builder, &0); + let prepared_ru_nvcsw = field_ru_nvcsw.prepare(builder, &0); + let prepared_ru_nivcsw = field_ru_nivcsw.prepare(builder, &0); + + let mut table_writer: ::planus::table_writer::TableWriter<36> = + ::core::default::Default::default(); + if prepared_ru_utime.is_some() { + table_writer.write_entry::(0); + } + if prepared_ru_stime.is_some() { + table_writer.write_entry::(1); + } + if prepared_ru_maxrss.is_some() { + table_writer.write_entry::(2); + } + if prepared_ru_ixrss.is_some() { + table_writer.write_entry::(3); + } + if prepared_ru_idrss.is_some() { + table_writer.write_entry::(4); + } + if prepared_ru_isrss.is_some() { + table_writer.write_entry::(5); + } + if prepared_ru_minflt.is_some() { + table_writer.write_entry::(6); + } + if prepared_ru_majflt.is_some() { + table_writer.write_entry::(7); + } + if prepared_ru_nswap.is_some() { + table_writer.write_entry::(8); + } + if prepared_ru_inblock.is_some() { + table_writer.write_entry::(9); + } + if prepared_ru_oublock.is_some() { + table_writer.write_entry::(10); + } + if prepared_ru_msgsnd.is_some() { + table_writer.write_entry::(11); + } + if prepared_ru_msgrcv.is_some() { + table_writer.write_entry::(12); + } + if prepared_ru_nsignals.is_some() { + table_writer.write_entry::(13); + } + if prepared_ru_nvcsw.is_some() { + table_writer.write_entry::(14); + } + if prepared_ru_nivcsw.is_some() { + table_writer.write_entry::(15); + } + + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_ru_utime) = + prepared_ru_utime + { + object_writer.write::<_, _, 8>(&prepared_ru_utime); + } + if let ::core::option::Option::Some(prepared_ru_stime) = + prepared_ru_stime + { + object_writer.write::<_, _, 8>(&prepared_ru_stime); + } + if let ::core::option::Option::Some(prepared_ru_maxrss) = + prepared_ru_maxrss + { + object_writer.write::<_, _, 8>(&prepared_ru_maxrss); + } + if let ::core::option::Option::Some(prepared_ru_ixrss) = + prepared_ru_ixrss + { + object_writer.write::<_, _, 8>(&prepared_ru_ixrss); + } + if let ::core::option::Option::Some(prepared_ru_idrss) = + prepared_ru_idrss + { + object_writer.write::<_, _, 8>(&prepared_ru_idrss); + } + if let ::core::option::Option::Some(prepared_ru_isrss) = + prepared_ru_isrss + { + object_writer.write::<_, _, 8>(&prepared_ru_isrss); + } + if let ::core::option::Option::Some(prepared_ru_minflt) = + prepared_ru_minflt + { + object_writer.write::<_, _, 8>(&prepared_ru_minflt); + } + if let ::core::option::Option::Some(prepared_ru_majflt) = + prepared_ru_majflt + { + object_writer.write::<_, _, 8>(&prepared_ru_majflt); + } + if let ::core::option::Option::Some(prepared_ru_nswap) = + prepared_ru_nswap + { + object_writer.write::<_, _, 8>(&prepared_ru_nswap); + } + if let ::core::option::Option::Some(prepared_ru_inblock) = + prepared_ru_inblock + { + object_writer.write::<_, _, 8>(&prepared_ru_inblock); + } + if let ::core::option::Option::Some(prepared_ru_oublock) = + prepared_ru_oublock + { + object_writer.write::<_, _, 8>(&prepared_ru_oublock); + } + if let ::core::option::Option::Some(prepared_ru_msgsnd) = + prepared_ru_msgsnd + { + object_writer.write::<_, _, 8>(&prepared_ru_msgsnd); + } + if let ::core::option::Option::Some(prepared_ru_msgrcv) = + prepared_ru_msgrcv + { + object_writer.write::<_, _, 8>(&prepared_ru_msgrcv); + } + if let ::core::option::Option::Some(prepared_ru_nsignals) = + prepared_ru_nsignals + { + object_writer.write::<_, _, 8>(&prepared_ru_nsignals); + } + if let ::core::option::Option::Some(prepared_ru_nvcsw) = + prepared_ru_nvcsw + { + object_writer.write::<_, _, 8>(&prepared_ru_nvcsw); + } + if let ::core::option::Option::Some(prepared_ru_nivcsw) = + prepared_ru_nivcsw + { + object_writer.write::<_, _, 8>(&prepared_ru_nivcsw); + } + }); + } + builder.current_offset() } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<28, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAs<::planus::Offset> for ResourceUsageResponse { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<29, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(29, (self.0).0.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<29, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptional<::planus::Offset> for ResourceUsageResponse { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) - } - } - impl ::planus::WriteAsUnion for BodyBuilder<::planus::Initialized<30, T>> - where - T: ::planus::WriteAsOffset, - { - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(30, (self.0).0.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> + { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for BodyBuilder<::planus::Initialized<30, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOffset for ResourceUsageResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + ResourceUsageResponse::create( + builder, + self.ru_utime, + self.ru_stime, + self.ru_maxrss, + self.ru_ixrss, + self.ru_idrss, + self.ru_isrss, + self.ru_minflt, + self.ru_majflt, + self.ru_nswap, + self.ru_inblock, + self.ru_oublock, + self.ru_msgsnd, + self.ru_msgrcv, + self.ru_nsignals, + self.ru_nvcsw, + self.ru_nivcsw, + ) } } - /// Reference to a deserialized [Body]. - #[derive(Copy, Clone, Debug)] - pub enum BodyRef<'a> { - FbsWorkerDumpResponse(super::worker::DumpResponseRef<'a>), - FbsWorkerResourceUsageResponse(super::worker::ResourceUsageResponseRef<'a>), - FbsWebRtcServerDumpResponse(super::web_rtc_server::DumpResponseRef<'a>), - FbsRouterDumpResponse(super::router::DumpResponseRef<'a>), - FbsTransportProduceResponse(super::transport::ProduceResponseRef<'a>), - FbsTransportConsumeResponse(super::transport::ConsumeResponseRef<'a>), - FbsTransportRestartIceResponse(super::transport::RestartIceResponseRef<'a>), - FbsPlainTransportConnectResponse(super::plain_transport::ConnectResponseRef<'a>), - FbsPlainTransportDumpResponse(super::plain_transport::DumpResponseRef<'a>), - FbsPlainTransportGetStatsResponse(super::plain_transport::GetStatsResponseRef<'a>), - FbsPipeTransportConnectResponse(super::pipe_transport::ConnectResponseRef<'a>), - FbsPipeTransportDumpResponse(super::pipe_transport::DumpResponseRef<'a>), - FbsPipeTransportGetStatsResponse(super::pipe_transport::GetStatsResponseRef<'a>), - FbsDirectTransportDumpResponse(super::direct_transport::DumpResponseRef<'a>), - FbsDirectTransportGetStatsResponse( - super::direct_transport::GetStatsResponseRef<'a>, - ), - FbsWebRtcTransportConnectResponse(super::web_rtc_transport::ConnectResponseRef<'a>), - FbsWebRtcTransportDumpResponse(super::web_rtc_transport::DumpResponseRef<'a>), - FbsWebRtcTransportGetStatsResponse( - super::web_rtc_transport::GetStatsResponseRef<'a>, - ), - FbsProducerDumpResponse(super::producer::DumpResponseRef<'a>), - FbsProducerGetStatsResponse(super::producer::GetStatsResponseRef<'a>), - FbsConsumerDumpResponse(super::consumer::DumpResponseRef<'a>), - FbsConsumerGetStatsResponse(super::consumer::GetStatsResponseRef<'a>), - FbsConsumerSetPreferredLayersResponse( - super::consumer::SetPreferredLayersResponseRef<'a>, - ), - FbsConsumerSetPriorityResponse(super::consumer::SetPriorityResponseRef<'a>), - FbsDataProducerDumpResponse(super::data_producer::DumpResponseRef<'a>), - FbsDataProducerGetStatsResponse(super::data_producer::GetStatsResponseRef<'a>), - FbsDataConsumerGetBufferedAmountResponse( - super::data_consumer::GetBufferedAmountResponseRef<'a>, - ), - FbsDataConsumerDumpResponse(super::data_consumer::DumpResponseRef<'a>), - FbsDataConsumerGetStatsResponse(super::data_consumer::GetStatsResponseRef<'a>), - FbsDataConsumerSetSubchannelsResponse( - super::data_consumer::SetSubchannelsResponseRef<'a>, - ), - } - - impl<'a> ::core::convert::TryFrom> for Body { - type Error = ::planus::Error; - - fn try_from(value: BodyRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - BodyRef::FbsWorkerDumpResponse(value) => { - Self::FbsWorkerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsWorkerResourceUsageResponse(value) => { - Self::FbsWorkerResourceUsageResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsWebRtcServerDumpResponse(value) => { - Self::FbsWebRtcServerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsRouterDumpResponse(value) => { - Self::FbsRouterDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsTransportProduceResponse(value) => { - Self::FbsTransportProduceResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsTransportConsumeResponse(value) => { - Self::FbsTransportConsumeResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsTransportRestartIceResponse(value) => { - Self::FbsTransportRestartIceResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsPlainTransportConnectResponse(value) => { - Self::FbsPlainTransportConnectResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsPlainTransportDumpResponse(value) => { - Self::FbsPlainTransportDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsPlainTransportGetStatsResponse(value) => { - Self::FbsPlainTransportGetStatsResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsPipeTransportConnectResponse(value) => { - Self::FbsPipeTransportConnectResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsPipeTransportDumpResponse(value) => { - Self::FbsPipeTransportDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsPipeTransportGetStatsResponse(value) => { - Self::FbsPipeTransportGetStatsResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsDirectTransportDumpResponse(value) => { - Self::FbsDirectTransportDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsDirectTransportGetStatsResponse(value) => { - Self::FbsDirectTransportGetStatsResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsWebRtcTransportConnectResponse(value) => { - Self::FbsWebRtcTransportConnectResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsWebRtcTransportDumpResponse(value) => { - Self::FbsWebRtcTransportDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsWebRtcTransportGetStatsResponse(value) => { - Self::FbsWebRtcTransportGetStatsResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - - BodyRef::FbsProducerDumpResponse(value) => { - Self::FbsProducerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsProducerGetStatsResponse(value) => { - Self::FbsProducerGetStatsResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsConsumerDumpResponse(value) => { - Self::FbsConsumerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - BodyRef::FbsConsumerGetStatsResponse(value) => { - Self::FbsConsumerGetStatsResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// Builder for serializing an instance of the [ResourceUsageResponse] type. + /// + /// Can be created using the [ResourceUsageResponse::builder] method. + #[derive(Debug)] + #[must_use] + pub struct ResourceUsageResponseBuilder(State); - BodyRef::FbsConsumerSetPreferredLayersResponse(value) => { - Self::FbsConsumerSetPreferredLayersResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } + impl ResourceUsageResponseBuilder<()> { + /// Setter for the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_utime(self, value: T0) -> ResourceUsageResponseBuilder<(T0,)> + where + T0: ::planus::WriteAsDefault, + { + ResourceUsageResponseBuilder((value,)) + } - BodyRef::FbsConsumerSetPriorityResponse(value) => { - Self::FbsConsumerSetPriorityResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// Sets the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_utime_as_default( + self, + ) -> ResourceUsageResponseBuilder<(::planus::DefaultValue,)> { + self.ru_utime(::planus::DefaultValue) + } + } - BodyRef::FbsDataProducerDumpResponse(value) => { - Self::FbsDataProducerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + impl ResourceUsageResponseBuilder<(T0,)> { + /// Setter for the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_stime(self, value: T1) -> ResourceUsageResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAsDefault, + { + let (v0,) = self.0; + ResourceUsageResponseBuilder((v0, value)) + } - BodyRef::FbsDataProducerGetStatsResponse(value) => { - Self::FbsDataProducerGetStatsResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// Sets the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_stime_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, ::planus::DefaultValue)> { + self.ru_stime(::planus::DefaultValue) + } + } - BodyRef::FbsDataConsumerGetBufferedAmountResponse(value) => { - Self::FbsDataConsumerGetBufferedAmountResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } + impl ResourceUsageResponseBuilder<(T0, T1)> { + /// Setter for the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_maxrss(self, value: T2) -> ResourceUsageResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsDefault, + { + let (v0, v1) = self.0; + ResourceUsageResponseBuilder((v0, v1, value)) + } - BodyRef::FbsDataConsumerDumpResponse(value) => { - Self::FbsDataConsumerDumpResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + /// Sets the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_maxrss_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, T1, ::planus::DefaultValue)> + { + self.ru_maxrss(::planus::DefaultValue) + } + } - BodyRef::FbsDataConsumerGetStatsResponse(value) => { - Self::FbsDataConsumerGetStatsResponse(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + impl ResourceUsageResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_ixrss( + self, + value: T3, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAsDefault, + { + let (v0, v1, v2) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, value)) + } - BodyRef::FbsDataConsumerSetSubchannelsResponse(value) => { - Self::FbsDataConsumerSetSubchannelsResponse( - ::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - ), - ) - } - }) + /// Sets the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_ixrss_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, ::planus::DefaultValue)> + { + self.ru_ixrss(::planus::DefaultValue) } } - impl<'a> ::planus::TableReadUnion<'a> for BodyRef<'a> { - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, - ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::FbsWorkerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::FbsWorkerResourceUsageResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 3 => ::core::result::Result::Ok(Self::FbsWebRtcServerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 4 => ::core::result::Result::Ok(Self::FbsRouterDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 5 => ::core::result::Result::Ok(Self::FbsTransportProduceResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 6 => ::core::result::Result::Ok(Self::FbsTransportConsumeResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 7 => ::core::result::Result::Ok(Self::FbsTransportRestartIceResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 8 => ::core::result::Result::Ok(Self::FbsPlainTransportConnectResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 9 => ::core::result::Result::Ok(Self::FbsPlainTransportDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 10 => ::core::result::Result::Ok(Self::FbsPlainTransportGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 11 => ::core::result::Result::Ok(Self::FbsPipeTransportConnectResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 12 => ::core::result::Result::Ok(Self::FbsPipeTransportDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 13 => ::core::result::Result::Ok(Self::FbsPipeTransportGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 14 => ::core::result::Result::Ok(Self::FbsDirectTransportDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 15 => ::core::result::Result::Ok(Self::FbsDirectTransportGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 16 => ::core::result::Result::Ok(Self::FbsWebRtcTransportConnectResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 17 => ::core::result::Result::Ok(Self::FbsWebRtcTransportDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 18 => ::core::result::Result::Ok(Self::FbsWebRtcTransportGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 19 => ::core::result::Result::Ok(Self::FbsProducerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 20 => ::core::result::Result::Ok(Self::FbsProducerGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 21 => ::core::result::Result::Ok(Self::FbsConsumerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 22 => ::core::result::Result::Ok(Self::FbsConsumerGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 23 => { - ::core::result::Result::Ok(Self::FbsConsumerSetPreferredLayersResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )) - } - 24 => ::core::result::Result::Ok(Self::FbsConsumerSetPriorityResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 25 => ::core::result::Result::Ok(Self::FbsDataProducerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 26 => ::core::result::Result::Ok(Self::FbsDataProducerGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 27 => ::core::result::Result::Ok( - Self::FbsDataConsumerGetBufferedAmountResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - ), - ), - 28 => ::core::result::Result::Ok(Self::FbsDataConsumerDumpResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 29 => ::core::result::Result::Ok(Self::FbsDataConsumerGetStatsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 30 => { - ::core::result::Result::Ok(Self::FbsDataConsumerSetSubchannelsResponse( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )) - } - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), - } + impl ResourceUsageResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_idrss( + self, + value: T4, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, value)) } - } - /// The table `Response` in the namespace `FBS.Response` - /// - /// Generated from these locations: - /// * Table `Response` in the file `../worker/fbs/response.fbs:45` - #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, - )] - pub struct Response { - /// The field `id` in the table `Response` - pub id: u32, - /// The field `accepted` in the table `Response` - pub accepted: bool, - /// The field `body` in the table `Response` - pub body: ::core::option::Option, - /// The field `error` in the table `Response` - pub error: ::core::option::Option<::planus::alloc::string::String>, - /// The field `reason` in the table `Response` - pub reason: ::core::option::Option<::planus::alloc::string::String>, + /// Sets the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_idrss_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> + { + self.ru_idrss(::planus::DefaultValue) + } } - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for Response { - fn default() -> Self { - Self { - id: 0, - accepted: false, - body: ::core::default::Default::default(), - error: ::core::default::Default::default(), - reason: ::core::default::Default::default(), - } + impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_isrss( + self, + value: T5, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, value)) + } + + /// Sets the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_isrss_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)> + { + self.ru_isrss(::planus::DefaultValue) } } - impl Response { - /// Creates a [ResponseBuilder] for serializing an instance of this table. + impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5)> { + /// Setter for the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt). #[inline] - pub fn builder() -> ResponseBuilder<()> { - ResponseBuilder(()) + #[allow(clippy::type_complexity)] + pub fn ru_minflt( + self, + value: T6, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> + where + T6: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, value)) } - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_id: impl ::planus::WriteAsDefault, - field_accepted: impl ::planus::WriteAsDefault, - field_body: impl ::planus::WriteAsOptionalUnion, - field_error: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, - >, - field_reason: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, - >, - ) -> ::planus::Offset { - let prepared_id = field_id.prepare(builder, &0); - let prepared_accepted = field_accepted.prepare(builder, &false); - let prepared_body = field_body.prepare(builder); - let prepared_error = field_error.prepare(builder); - let prepared_reason = field_reason.prepare(builder); + /// Sets the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_minflt_as_default( + self, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)> + { + self.ru_minflt(::planus::DefaultValue) + } + } - let mut table_writer: ::planus::table_writer::TableWriter<16> = - ::core::default::Default::default(); - if prepared_id.is_some() { - table_writer.write_entry::(0); - } - if prepared_body.is_some() { - table_writer.write_entry::<::planus::Offset>(3); - } - if prepared_error.is_some() { - table_writer.write_entry::<::planus::Offset>(4); - } - if prepared_reason.is_some() { - table_writer.write_entry::<::planus::Offset>(5); - } - if prepared_accepted.is_some() { - table_writer.write_entry::(1); - } - if prepared_body.is_some() { - table_writer.write_entry::(2); - } + impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { + /// Setter for the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_majflt( + self, + value: T7, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + where + T7: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5, v6) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + } - unsafe { - table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_id) = prepared_id { - object_writer.write::<_, _, 4>(&prepared_id); - } - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 4>(&prepared_body.offset()); - } - if let ::core::option::Option::Some(prepared_error) = prepared_error { - object_writer.write::<_, _, 4>(&prepared_error); - } - if let ::core::option::Option::Some(prepared_reason) = prepared_reason { - object_writer.write::<_, _, 4>(&prepared_reason); - } - if let ::core::option::Option::Some(prepared_accepted) = - prepared_accepted - { - object_writer.write::<_, _, 1>(&prepared_accepted); - } - if let ::core::option::Option::Some(prepared_body) = prepared_body { - object_writer.write::<_, _, 1>(&prepared_body.tag()); - } - }); - } - builder.current_offset() + /// Sets the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_majflt_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + ::planus::DefaultValue, + )> { + self.ru_majflt(::planus::DefaultValue) } } - impl ::planus::WriteAs<::planus::Offset> for Response { - type Prepared = ::planus::Offset; + impl + ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + { + /// Setter for the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_nswap( + self, + value: T8, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + where + T8: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value)) + } + /// Sets the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap) to the default value. #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + #[allow(clippy::type_complexity)] + pub fn ru_nswap_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + ::planus::DefaultValue, + )> { + self.ru_nswap(::planus::DefaultValue) } } - impl ::planus::WriteAsOptional<::planus::Offset> for Response { - type Prepared = ::planus::Offset; + impl + ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + { + /// Setter for the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_inblock( + self, + value: T9, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + where + T9: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, value)) + } + /// Sets the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock) to the default value. #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + #[allow(clippy::type_complexity)] + pub fn ru_inblock_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + ::planus::DefaultValue, + )> { + self.ru_inblock(::planus::DefaultValue) } } - impl ::planus::WriteAsOffset for Response { + impl + ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + { + /// Setter for the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock). #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - Response::create( - builder, - self.id, - self.accepted, - &self.body, - &self.error, - &self.reason, - ) + #[allow(clippy::type_complexity)] + pub fn ru_oublock( + self, + value: T10, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + where + T10: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) = self.0; + ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, value)) } - } - /// Builder for serializing an instance of the [Response] type. - /// - /// Can be created using the [Response::builder] method. - #[derive(Debug)] - #[must_use] - pub struct ResponseBuilder(State); + /// Sets the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ru_oublock_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + ::planus::DefaultValue, + )> { + self.ru_oublock(::planus::DefaultValue) + } + } - impl ResponseBuilder<()> { - /// Setter for the [`id` field](Response#structfield.id). + impl + ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + { + /// Setter for the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd). #[inline] #[allow(clippy::type_complexity)] - pub fn id(self, value: T0) -> ResponseBuilder<(T0,)> + pub fn ru_msgsnd( + self, + value: T11, + ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> where - T0: ::planus::WriteAsDefault, + T11: ::planus::WriteAsDefault, { - ResponseBuilder((value,)) + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = self.0; + ResourceUsageResponseBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, value, + )) } - /// Sets the [`id` field](Response#structfield.id) to the default value. + /// Sets the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn id_as_default(self) -> ResponseBuilder<(::planus::DefaultValue,)> { - self.id(::planus::DefaultValue) + pub fn ru_msgsnd_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + ::planus::DefaultValue, + )> { + self.ru_msgsnd(::planus::DefaultValue) } } - impl ResponseBuilder<(T0,)> { - /// Setter for the [`accepted` field](Response#structfield.accepted). + impl + ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + { + /// Setter for the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv). #[inline] #[allow(clippy::type_complexity)] - pub fn accepted(self, value: T1) -> ResponseBuilder<(T0, T1)> + pub fn ru_msgrcv( + self, + value: T12, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + )> where - T1: ::planus::WriteAsDefault, + T12: ::planus::WriteAsDefault, { - let (v0,) = self.0; - ResponseBuilder((v0, value)) + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) = self.0; + ResourceUsageResponseBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, value, + )) } - /// Sets the [`accepted` field](Response#structfield.accepted) to the default value. + /// Sets the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn accepted_as_default(self) -> ResponseBuilder<(T0, ::planus::DefaultValue)> { - self.accepted(::planus::DefaultValue) + pub fn ru_msgrcv_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + ::planus::DefaultValue, + )> { + self.ru_msgrcv(::planus::DefaultValue) } } - impl ResponseBuilder<(T0, T1)> { - /// Setter for the [`body` field](Response#structfield.body). + impl + ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + )> + { + /// Setter for the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals). #[inline] #[allow(clippy::type_complexity)] - pub fn body(self, value: T2) -> ResponseBuilder<(T0, T1, T2)> + pub fn ru_nsignals( + self, + value: T13, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + )> where - T2: ::planus::WriteAsOptionalUnion, + T13: ::planus::WriteAsDefault, { - let (v0, v1) = self.0; - ResponseBuilder((v0, v1, value)) + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) = self.0; + ResourceUsageResponseBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, value, + )) } - /// Sets the [`body` field](Response#structfield.body) to null. + /// Sets the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn body_as_null(self) -> ResponseBuilder<(T0, T1, ())> { - self.body(()) + pub fn ru_nsignals_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + ::planus::DefaultValue, + )> { + self.ru_nsignals(::planus::DefaultValue) } } - impl ResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`error` field](Response#structfield.error). + impl + ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + )> + { + /// Setter for the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw). #[inline] #[allow(clippy::type_complexity)] - pub fn error(self, value: T3) -> ResponseBuilder<(T0, T1, T2, T3)> + pub fn ru_nvcsw( + self, + value: T14, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + )> where - T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T14: ::planus::WriteAsDefault, { - let (v0, v1, v2) = self.0; - ResponseBuilder((v0, v1, v2, value)) + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) = self.0; + ResourceUsageResponseBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, value, + )) } - /// Sets the [`error` field](Response#structfield.error) to null. + /// Sets the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn error_as_null(self) -> ResponseBuilder<(T0, T1, T2, ())> { - self.error(()) + pub fn ru_nvcsw_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + ::planus::DefaultValue, + )> { + self.ru_nvcsw(::planus::DefaultValue) } } - impl ResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`reason` field](Response#structfield.reason). + impl + ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + )> + { + /// Setter for the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw). #[inline] #[allow(clippy::type_complexity)] - pub fn reason(self, value: T4) -> ResponseBuilder<(T0, T1, T2, T3, T4)> + pub fn ru_nivcsw( + self, + value: T15, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + )> where - T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T15: ::planus::WriteAsDefault, { - let (v0, v1, v2, v3) = self.0; - ResponseBuilder((v0, v1, v2, v3, value)) + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) = self.0; + ResourceUsageResponseBuilder(( + v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, value, + )) } - /// Sets the [`reason` field](Response#structfield.reason) to null. + /// Sets the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn reason_as_null(self) -> ResponseBuilder<(T0, T1, T2, T3, ())> { - self.reason(()) + pub fn ru_nivcsw_as_default( + self, + ) -> ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + ::planus::DefaultValue, + )> { + self.ru_nivcsw(::planus::DefaultValue) } } - impl ResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Response]. + impl + ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + )> + { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ResourceUsageResponse]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAs<::planus::Offset> - for ResponseBuilder<(T0, T1, T2, T3, T4)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsDefault, + T7: ::planus::WriteAsDefault, + T8: ::planus::WriteAsDefault, + T9: ::planus::WriteAsDefault, + T10: ::planus::WriteAsDefault, + T11: ::planus::WriteAsDefault, + T12: ::planus::WriteAsDefault, + T13: ::planus::WriteAsDefault, + T14: ::planus::WriteAsDefault, + T15: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> + for ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + )> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOptional<::planus::Offset> - for ResponseBuilder<(T0, T1, T2, T3, T4)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsDefault, + T7: ::planus::WriteAsDefault, + T8: ::planus::WriteAsDefault, + T9: ::planus::WriteAsDefault, + T10: ::planus::WriteAsDefault, + T11: ::planus::WriteAsDefault, + T12: ::planus::WriteAsDefault, + T13: ::planus::WriteAsDefault, + T14: ::planus::WriteAsDefault, + T15: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + )> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsOptionalUnion, - T3: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T4: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOffset for ResponseBuilder<(T0, T1, T2, T3, T4)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsDefault, + T7: ::planus::WriteAsDefault, + T8: ::planus::WriteAsDefault, + T9: ::planus::WriteAsDefault, + T10: ::planus::WriteAsDefault, + T11: ::planus::WriteAsDefault, + T12: ::planus::WriteAsDefault, + T13: ::planus::WriteAsDefault, + T14: ::planus::WriteAsDefault, + T15: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset + for ResourceUsageResponseBuilder<( + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + )> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0, v1, v2, v3, v4) = &self.0; - Response::create(builder, v0, v1, v2, v3, v4) - } - } - - /// Reference to a deserialized [Response]. - #[derive(Copy, Clone)] - pub struct ResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> ResponseRef<'a> { - /// Getter for the [`id` field](Response#structfield.id). - #[inline] - pub fn id(&self) -> ::planus::Result { - ::core::result::Result::Ok(self.0.access(0, "Response", "id")?.unwrap_or(0)) - } - - /// Getter for the [`accepted` field](Response#structfield.accepted). - #[inline] - pub fn accepted(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0.access(1, "Response", "accepted")?.unwrap_or(false), - ) - } - - /// Getter for the [`body` field](Response#structfield.body). - #[inline] - pub fn body(&self) -> ::planus::Result<::core::option::Option>> { - self.0.access_union(2, "Response", "body") - } - - /// Getter for the [`error` field](Response#structfield.error). - #[inline] - pub fn error( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(4, "Response", "error") - } - - /// Getter for the [`reason` field](Response#structfield.reason). - #[inline] - pub fn reason( + fn prepare( &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(5, "Response", "reason") - } - } - - impl<'a> ::core::fmt::Debug for ResponseRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ResponseRef"); - f.field("id", &self.id()); - f.field("accepted", &self.accepted()); - if let ::core::option::Option::Some(field_body) = self.body().transpose() { - f.field("body", &field_body); - } - if let ::core::option::Option::Some(field_error) = self.error().transpose() { - f.field("error", &field_error); - } - if let ::core::option::Option::Some(field_reason) = self.reason().transpose() { - f.field("reason", &field_reason); - } - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for Response { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: ResponseRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - id: ::core::convert::TryInto::try_into(value.id()?)?, - accepted: ::core::convert::TryInto::try_into(value.accepted()?)?, - body: if let ::core::option::Option::Some(body) = value.body()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(body)?) - } else { - ::core::option::Option::None - }, - error: if let ::core::option::Option::Some(error) = value.error()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(error)?) - } else { - ::core::option::Option::None - }, - reason: if let ::core::option::Option::Some(reason) = value.reason()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into( - reason, - )?) - } else { - ::core::option::Option::None - }, - }) - } - } - - impl<'a> ::planus::TableRead<'a> for ResponseRef<'a> { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) - } - } - - impl<'a> ::planus::VectorReadInner<'a> for ResponseRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[ResponseRef]", - "get", - buffer.offset_from_start, - ) - }) - } - } - - impl ::planus::VectorWrite<::planus::Offset> for Response { - type Value = ::planus::Offset; - const STRIDE: usize = 4; - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) - } - - #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); - } - } - } - - impl<'a> ::planus::ReadAsRoot<'a> for ResponseRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[ResponseRef]", "read_as_root", 0) - }) - } - } - } - /// The namespace `FBS.Worker` - /// - /// Generated from these locations: - /// * File `../worker/fbs/worker.fbs` - pub mod worker { - /// The table `ChannelMessageHandlers` in the namespace `FBS.Worker` - /// - /// Generated from these locations: - /// * Table `ChannelMessageHandlers` in the file `../worker/fbs/worker.fbs:5` - #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - pub struct ChannelMessageHandlers { - /// The field `channel_request_handlers` in the table `ChannelMessageHandlers` - pub channel_request_handlers: - ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `channel_notification_handlers` in the table `ChannelMessageHandlers` - pub channel_notification_handlers: - ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - } - - impl ChannelMessageHandlers { - /// Creates a [ChannelMessageHandlersBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> ChannelMessageHandlersBuilder<()> { - ChannelMessageHandlersBuilder(()) - } - - #[allow(clippy::too_many_arguments)] - pub fn create( builder: &mut ::planus::Builder, - field_channel_request_handlers: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_channel_notification_handlers: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - ) -> ::planus::Offset { - let prepared_channel_request_handlers = - field_channel_request_handlers.prepare(builder); - let prepared_channel_notification_handlers = - field_channel_notification_handlers.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<8> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); - - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_channel_request_handlers); - object_writer.write::<_, _, 4>(&prepared_channel_notification_handlers); - }); - } - builder.current_offset() + ) -> ::planus::Offset { + let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) = + &self.0; + ResourceUsageResponse::create( + builder, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, + v15, + ) } } - impl ::planus::WriteAs<::planus::Offset> for ChannelMessageHandlers { - type Prepared = ::planus::Offset; + /// Reference to a deserialized [ResourceUsageResponse]. + #[derive(Copy, Clone)] + pub struct ResourceUsageResponseRef<'a>(::planus::table_reader::Table<'a>); + impl<'a> ResourceUsageResponseRef<'a> { + /// Getter for the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + pub fn ru_utime(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "ResourceUsageResponse", "ru_utime")? + .unwrap_or(0), + ) } - } - impl ::planus::WriteAsOptional<::planus::Offset> - for ChannelMessageHandlers - { - type Prepared = ::planus::Offset; + /// Getter for the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime). + #[inline] + pub fn ru_stime(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "ResourceUsageResponse", "ru_stime")? + .unwrap_or(0), + ) + } + /// Getter for the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + pub fn ru_maxrss(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(2, "ResourceUsageResponse", "ru_maxrss")? + .unwrap_or(0), + ) } - } - impl ::planus::WriteAsOffset for ChannelMessageHandlers { + /// Getter for the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ChannelMessageHandlers::create( - builder, - &self.channel_request_handlers, - &self.channel_notification_handlers, + pub fn ru_ixrss(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(3, "ResourceUsageResponse", "ru_ixrss")? + .unwrap_or(0), ) } - } - /// Builder for serializing an instance of the [ChannelMessageHandlers] type. - /// - /// Can be created using the [ChannelMessageHandlers::builder] method. - #[derive(Debug)] - #[must_use] - pub struct ChannelMessageHandlersBuilder(State); + /// Getter for the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss). + #[inline] + pub fn ru_idrss(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(4, "ResourceUsageResponse", "ru_idrss")? + .unwrap_or(0), + ) + } - impl ChannelMessageHandlersBuilder<()> { - /// Setter for the [`channel_request_handlers` field](ChannelMessageHandlers#structfield.channel_request_handlers). + /// Getter for the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss). #[inline] - #[allow(clippy::type_complexity)] - pub fn channel_request_handlers( - self, - value: T0, - ) -> ChannelMessageHandlersBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - ChannelMessageHandlersBuilder((value,)) + pub fn ru_isrss(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(5, "ResourceUsageResponse", "ru_isrss")? + .unwrap_or(0), + ) } - } - impl ChannelMessageHandlersBuilder<(T0,)> { - /// Setter for the [`channel_notification_handlers` field](ChannelMessageHandlers#structfield.channel_notification_handlers). + /// Getter for the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt). #[inline] - #[allow(clippy::type_complexity)] - pub fn channel_notification_handlers( - self, - value: T1, - ) -> ChannelMessageHandlersBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0,) = self.0; - ChannelMessageHandlersBuilder((v0, value)) + pub fn ru_minflt(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(6, "ResourceUsageResponse", "ru_minflt")? + .unwrap_or(0), + ) } - } - impl ChannelMessageHandlersBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ChannelMessageHandlers]. + /// Getter for the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt). #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) + pub fn ru_majflt(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(7, "ResourceUsageResponse", "ru_majflt")? + .unwrap_or(0), + ) } - } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAs<::planus::Offset> - for ChannelMessageHandlersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; + /// Getter for the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap). + #[inline] + pub fn ru_nswap(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(8, "ResourceUsageResponse", "ru_nswap")? + .unwrap_or(0), + ) + } + /// Getter for the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + pub fn ru_inblock(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(9, "ResourceUsageResponse", "ru_inblock")? + .unwrap_or(0), + ) } - } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOptional<::planus::Offset> - for ChannelMessageHandlersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; + /// Getter for the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock). + #[inline] + pub fn ru_oublock(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(10, "ResourceUsageResponse", "ru_oublock")? + .unwrap_or(0), + ) + } + /// Getter for the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + pub fn ru_msgsnd(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(11, "ResourceUsageResponse", "ru_msgsnd")? + .unwrap_or(0), + ) } - } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOffset - for ChannelMessageHandlersBuilder<(T0, T1)> - { + /// Getter for the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - ChannelMessageHandlers::create(builder, v0, v1) + pub fn ru_msgrcv(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(12, "ResourceUsageResponse", "ru_msgrcv")? + .unwrap_or(0), + ) } - } - /// Reference to a deserialized [ChannelMessageHandlers]. - #[derive(Copy, Clone)] - pub struct ChannelMessageHandlersRef<'a>(::planus::table_reader::Table<'a>); + /// Getter for the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals). + #[inline] + pub fn ru_nsignals(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(13, "ResourceUsageResponse", "ru_nsignals")? + .unwrap_or(0), + ) + } - impl<'a> ChannelMessageHandlersRef<'a> { - /// Getter for the [`channel_request_handlers` field](ChannelMessageHandlers#structfield.channel_request_handlers). + /// Getter for the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw). #[inline] - pub fn channel_request_handlers( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0 - .access_required(0, "ChannelMessageHandlers", "channel_request_handlers") + pub fn ru_nvcsw(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(14, "ResourceUsageResponse", "ru_nvcsw")? + .unwrap_or(0), + ) } - /// Getter for the [`channel_notification_handlers` field](ChannelMessageHandlers#structfield.channel_notification_handlers). + /// Getter for the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw). #[inline] - pub fn channel_notification_handlers( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0.access_required( - 1, - "ChannelMessageHandlers", - "channel_notification_handlers", + pub fn ru_nivcsw(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(15, "ResourceUsageResponse", "ru_nivcsw")? + .unwrap_or(0), ) } } - impl<'a> ::core::fmt::Debug for ChannelMessageHandlersRef<'a> { + impl<'a> ::core::fmt::Debug for ResourceUsageResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ChannelMessageHandlersRef"); - f.field("channel_request_handlers", &self.channel_request_handlers()); - f.field( - "channel_notification_handlers", - &self.channel_notification_handlers(), - ); + let mut f = f.debug_struct("ResourceUsageResponseRef"); + f.field("ru_utime", &self.ru_utime()); + f.field("ru_stime", &self.ru_stime()); + f.field("ru_maxrss", &self.ru_maxrss()); + f.field("ru_ixrss", &self.ru_ixrss()); + f.field("ru_idrss", &self.ru_idrss()); + f.field("ru_isrss", &self.ru_isrss()); + f.field("ru_minflt", &self.ru_minflt()); + f.field("ru_majflt", &self.ru_majflt()); + f.field("ru_nswap", &self.ru_nswap()); + f.field("ru_inblock", &self.ru_inblock()); + f.field("ru_oublock", &self.ru_oublock()); + f.field("ru_msgsnd", &self.ru_msgsnd()); + f.field("ru_msgrcv", &self.ru_msgrcv()); + f.field("ru_nsignals", &self.ru_nsignals()); + f.field("ru_nvcsw", &self.ru_nvcsw()); + f.field("ru_nivcsw", &self.ru_nivcsw()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ChannelMessageHandlers { + impl<'a> ::core::convert::TryFrom> for ResourceUsageResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ChannelMessageHandlersRef<'a>) -> ::planus::Result { + fn try_from(value: ResourceUsageResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - channel_request_handlers: value - .channel_request_handlers()? - .to_vec_result()?, - channel_notification_handlers: value - .channel_notification_handlers()? - .to_vec_result()?, + ru_utime: ::core::convert::TryInto::try_into(value.ru_utime()?)?, + ru_stime: ::core::convert::TryInto::try_into(value.ru_stime()?)?, + ru_maxrss: ::core::convert::TryInto::try_into(value.ru_maxrss()?)?, + ru_ixrss: ::core::convert::TryInto::try_into(value.ru_ixrss()?)?, + ru_idrss: ::core::convert::TryInto::try_into(value.ru_idrss()?)?, + ru_isrss: ::core::convert::TryInto::try_into(value.ru_isrss()?)?, + ru_minflt: ::core::convert::TryInto::try_into(value.ru_minflt()?)?, + ru_majflt: ::core::convert::TryInto::try_into(value.ru_majflt()?)?, + ru_nswap: ::core::convert::TryInto::try_into(value.ru_nswap()?)?, + ru_inblock: ::core::convert::TryInto::try_into(value.ru_inblock()?)?, + ru_oublock: ::core::convert::TryInto::try_into(value.ru_oublock()?)?, + ru_msgsnd: ::core::convert::TryInto::try_into(value.ru_msgsnd()?)?, + ru_msgrcv: ::core::convert::TryInto::try_into(value.ru_msgrcv()?)?, + ru_nsignals: ::core::convert::TryInto::try_into(value.ru_nsignals()?)?, + ru_nvcsw: ::core::convert::TryInto::try_into(value.ru_nvcsw()?)?, + ru_nivcsw: ::core::convert::TryInto::try_into(value.ru_nivcsw()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for ChannelMessageHandlersRef<'a> { + impl<'a> ::planus::TableRead<'a> for ResourceUsageResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -56433,7 +58510,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ChannelMessageHandlersRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ResourceUsageResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -56443,7 +58520,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ChannelMessageHandlersRef]", + "[ResourceUsageResponseRef]", "get", buffer.offset_from_start, ) @@ -56451,8 +58528,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ChannelMessageHandlers { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ResourceUsageResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -56461,7 +58538,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -56476,7 +58553,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ChannelMessageHandlersRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ResourceUsageResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -56487,7 +58564,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[ChannelMessageHandlersRef]", + "[ResourceUsageResponseRef]", "read_as_root", 0, ) @@ -56495,10 +58572,10 @@ mod root { } } - /// The table `DumpResponse` in the namespace `FBS.Worker` + /// The table `UpdateSettingsRequest` in the namespace `FBS.Worker` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/worker.fbs:10` + /// * Table `UpdateSettingsRequest` in the file `../worker/fbs/worker.fbs:36` #[derive( Clone, Debug, @@ -56510,315 +58587,289 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct DumpResponse { - /// The field `pid` in the table `DumpResponse` - pub pid: u32, - /// The field `web_rtc_server_ids` in the table `DumpResponse` - pub web_rtc_server_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `router_ids` in the table `DumpResponse` - pub router_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `channel_message_handlers` in the table `DumpResponse` - pub channel_message_handlers: - ::planus::alloc::boxed::Box, + pub struct UpdateSettingsRequest { + /// The field `log_level` in the table `UpdateSettingsRequest` + pub log_level: ::core::option::Option<::planus::alloc::string::String>, + /// The field `log_tags` in the table `UpdateSettingsRequest` + pub log_tags: ::core::option::Option< + ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + >, } - impl DumpResponse { - /// Creates a [DumpResponseBuilder] for serializing an instance of this table. + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for UpdateSettingsRequest { + fn default() -> Self { + Self { + log_level: ::core::default::Default::default(), + log_tags: ::core::default::Default::default(), + } + } + } + + impl UpdateSettingsRequest { + /// Creates a [UpdateSettingsRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> DumpResponseBuilder<()> { - DumpResponseBuilder(()) + pub fn builder() -> UpdateSettingsRequestBuilder<()> { + UpdateSettingsRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_pid: impl ::planus::WriteAsDefault, - field_web_rtc_server_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + field_log_level: impl ::planus::WriteAsOptional< + ::planus::Offset<::core::primitive::str>, >, - field_router_ids: impl ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - field_channel_message_handlers: impl ::planus::WriteAs< - ::planus::Offset, + field_log_tags: impl ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, >, ) -> ::planus::Offset { - let prepared_pid = field_pid.prepare(builder, &0); - let prepared_web_rtc_server_ids = field_web_rtc_server_ids.prepare(builder); - let prepared_router_ids = field_router_ids.prepare(builder); - let prepared_channel_message_handlers = - field_channel_message_handlers.prepare(builder); + let prepared_log_level = field_log_level.prepare(builder); + let prepared_log_tags = field_log_tags.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<12> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - if prepared_pid.is_some() { - table_writer.write_entry::(0); + if prepared_log_level.is_some() { + table_writer.write_entry::<::planus::Offset>(0); + } + if prepared_log_tags.is_some() { + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); } - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(2); - table_writer.write_entry::<::planus::Offset>(3); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_pid) = prepared_pid { - object_writer.write::<_, _, 4>(&prepared_pid); + if let ::core::option::Option::Some(prepared_log_level) = + prepared_log_level + { + object_writer.write::<_, _, 4>(&prepared_log_level); + } + if let ::core::option::Option::Some(prepared_log_tags) = + prepared_log_tags + { + object_writer.write::<_, _, 4>(&prepared_log_tags); } - object_writer.write::<_, _, 4>(&prepared_web_rtc_server_ids); - object_writer.write::<_, _, 4>(&prepared_router_ids); - object_writer.write::<_, _, 4>(&prepared_channel_message_handlers); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + impl ::planus::WriteAs<::planus::Offset> for UpdateSettingsRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + impl ::planus::WriteAsOptional<::planus::Offset> for UpdateSettingsRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for DumpResponse { + impl ::planus::WriteAsOffset for UpdateSettingsRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DumpResponse::create( - builder, - self.pid, - &self.web_rtc_server_ids, - &self.router_ids, - &self.channel_message_handlers, - ) + ) -> ::planus::Offset { + UpdateSettingsRequest::create(builder, &self.log_level, &self.log_tags) } } - /// Builder for serializing an instance of the [DumpResponse] type. + /// Builder for serializing an instance of the [UpdateSettingsRequest] type. /// - /// Can be created using the [DumpResponse::builder] method. + /// Can be created using the [UpdateSettingsRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct DumpResponseBuilder(State); + pub struct UpdateSettingsRequestBuilder(State); - impl DumpResponseBuilder<()> { - /// Setter for the [`pid` field](DumpResponse#structfield.pid). + impl UpdateSettingsRequestBuilder<()> { + /// Setter for the [`log_level` field](UpdateSettingsRequest#structfield.log_level). #[inline] #[allow(clippy::type_complexity)] - pub fn pid(self, value: T0) -> DumpResponseBuilder<(T0,)> + pub fn log_level(self, value: T0) -> UpdateSettingsRequestBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, { - DumpResponseBuilder((value,)) + UpdateSettingsRequestBuilder((value,)) } - /// Sets the [`pid` field](DumpResponse#structfield.pid) to the default value. + /// Sets the [`log_level` field](UpdateSettingsRequest#structfield.log_level) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn pid_as_default(self) -> DumpResponseBuilder<(::planus::DefaultValue,)> { - self.pid(::planus::DefaultValue) + pub fn log_level_as_null(self) -> UpdateSettingsRequestBuilder<((),)> { + self.log_level(()) } } - impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`web_rtc_server_ids` field](DumpResponse#structfield.web_rtc_server_ids). + impl UpdateSettingsRequestBuilder<(T0,)> { + /// Setter for the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags). #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_server_ids(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + pub fn log_tags(self, value: T1) -> UpdateSettingsRequestBuilder<(T0, T1)> where - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, { let (v0,) = self.0; - DumpResponseBuilder((v0, value)) - } - } - - impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`router_ids` field](DumpResponse#structfield.router_ids). - #[inline] - #[allow(clippy::type_complexity)] - pub fn router_ids(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0, v1) = self.0; - DumpResponseBuilder((v0, v1, value)) + UpdateSettingsRequestBuilder((v0, value)) } - } - impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`channel_message_handlers` field](DumpResponse#structfield.channel_message_handlers). + /// Sets the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn channel_message_handlers( - self, - value: T3, - ) -> DumpResponseBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAs<::planus::Offset>, - { - let (v0, v1, v2) = self.0; - DumpResponseBuilder((v0, v1, v2, value)) + pub fn log_tags_as_null(self) -> UpdateSettingsRequestBuilder<(T0, ())> { + self.log_tags(()) } } - impl DumpResponseBuilder<(T0, T1, T2, T3)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + impl UpdateSettingsRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [UpdateSettingsRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAs<::planus::Offset> + for UpdateSettingsRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOptional<::planus::Offset> + for UpdateSettingsRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset for DumpResponseBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOffset + for UpdateSettingsRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + UpdateSettingsRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [DumpResponse]. + /// Reference to a deserialized [UpdateSettingsRequest]. #[derive(Copy, Clone)] - pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> DumpResponseRef<'a> { - /// Getter for the [`pid` field](DumpResponse#structfield.pid). - #[inline] - pub fn pid(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0.access(0, "DumpResponse", "pid")?.unwrap_or(0), - ) - } + pub struct UpdateSettingsRequestRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`web_rtc_server_ids` field](DumpResponse#structfield.web_rtc_server_ids). + impl<'a> UpdateSettingsRequestRef<'a> { + /// Getter for the [`log_level` field](UpdateSettingsRequest#structfield.log_level). #[inline] - pub fn web_rtc_server_ids( + pub fn log_level( &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0 - .access_required(1, "DumpResponse", "web_rtc_server_ids") + ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> + { + self.0.access(0, "UpdateSettingsRequest", "log_level") } - /// Getter for the [`router_ids` field](DumpResponse#structfield.router_ids). + /// Getter for the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags). #[inline] - pub fn router_ids( + pub fn log_tags( &self, ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + ::core::option::Option< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + >, > { - self.0.access_required(2, "DumpResponse", "router_ids") - } - - /// Getter for the [`channel_message_handlers` field](DumpResponse#structfield.channel_message_handlers). - #[inline] - pub fn channel_message_handlers( - &self, - ) -> ::planus::Result> { - self.0 - .access_required(3, "DumpResponse", "channel_message_handlers") + self.0.access(1, "UpdateSettingsRequest", "log_tags") } } - impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + impl<'a> ::core::fmt::Debug for UpdateSettingsRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DumpResponseRef"); - f.field("pid", &self.pid()); - f.field("web_rtc_server_ids", &self.web_rtc_server_ids()); - f.field("router_ids", &self.router_ids()); - f.field("channel_message_handlers", &self.channel_message_handlers()); + let mut f = f.debug_struct("UpdateSettingsRequestRef"); + if let ::core::option::Option::Some(field_log_level) = + self.log_level().transpose() + { + f.field("log_level", &field_log_level); + } + if let ::core::option::Option::Some(field_log_tags) = + self.log_tags().transpose() + { + f.field("log_tags", &field_log_tags); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for DumpResponse { + impl<'a> ::core::convert::TryFrom> for UpdateSettingsRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { + fn try_from(value: UpdateSettingsRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - pid: ::core::convert::TryInto::try_into(value.pid()?)?, - web_rtc_server_ids: value.web_rtc_server_ids()?.to_vec_result()?, - router_ids: value.router_ids()?.to_vec_result()?, - channel_message_handlers: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.channel_message_handlers()?)?, - ), + log_level: if let ::core::option::Option::Some(log_level) = + value.log_level()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + log_level, + )?) + } else { + ::core::option::Option::None + }, + log_tags: if let ::core::option::Option::Some(log_tags) = + value.log_tags()? + { + ::core::option::Option::Some(log_tags.to_vec_result()?) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for UpdateSettingsRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -56830,7 +58881,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for UpdateSettingsRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -56840,7 +58891,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[DumpResponseRef]", + "[UpdateSettingsRequestRef]", "get", buffer.offset_from_start, ) @@ -56848,8 +58899,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for UpdateSettingsRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -56858,7 +58909,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -56873,7 +58924,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for UpdateSettingsRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -56883,15 +58934,19 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + error_kind.with_error_location( + "[UpdateSettingsRequestRef]", + "read_as_root", + 0, + ) }) } } - /// The table `ResourceUsageResponse` in the namespace `FBS.Worker` + /// The table `CreateWebRtcServerRequest` in the namespace `FBS.Worker` /// /// Generated from these locations: - /// * Table `ResourceUsageResponse` in the file `../worker/fbs/worker.fbs:17` + /// * Table `CreateWebRtcServerRequest` in the file `../worker/fbs/worker.fbs:41` #[derive( Clone, Debug, @@ -56903,241 +58958,48 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct ResourceUsageResponse { - /// The field `ru_utime` in the table `ResourceUsageResponse` - pub ru_utime: u64, - /// The field `ru_stime` in the table `ResourceUsageResponse` - pub ru_stime: u64, - /// The field `ru_maxrss` in the table `ResourceUsageResponse` - pub ru_maxrss: u64, - /// The field `ru_ixrss` in the table `ResourceUsageResponse` - pub ru_ixrss: u64, - /// The field `ru_idrss` in the table `ResourceUsageResponse` - pub ru_idrss: u64, - /// The field `ru_isrss` in the table `ResourceUsageResponse` - pub ru_isrss: u64, - /// The field `ru_minflt` in the table `ResourceUsageResponse` - pub ru_minflt: u64, - /// The field `ru_majflt` in the table `ResourceUsageResponse` - pub ru_majflt: u64, - /// The field `ru_nswap` in the table `ResourceUsageResponse` - pub ru_nswap: u64, - /// The field `ru_inblock` in the table `ResourceUsageResponse` - pub ru_inblock: u64, - /// The field `ru_oublock` in the table `ResourceUsageResponse` - pub ru_oublock: u64, - /// The field `ru_msgsnd` in the table `ResourceUsageResponse` - pub ru_msgsnd: u64, - /// The field `ru_msgrcv` in the table `ResourceUsageResponse` - pub ru_msgrcv: u64, - /// The field `ru_nsignals` in the table `ResourceUsageResponse` - pub ru_nsignals: u64, - /// The field `ru_nvcsw` in the table `ResourceUsageResponse` - pub ru_nvcsw: u64, - /// The field `ru_nivcsw` in the table `ResourceUsageResponse` - pub ru_nivcsw: u64, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for ResourceUsageResponse { - fn default() -> Self { - Self { - ru_utime: 0, - ru_stime: 0, - ru_maxrss: 0, - ru_ixrss: 0, - ru_idrss: 0, - ru_isrss: 0, - ru_minflt: 0, - ru_majflt: 0, - ru_nswap: 0, - ru_inblock: 0, - ru_oublock: 0, - ru_msgsnd: 0, - ru_msgrcv: 0, - ru_nsignals: 0, - ru_nvcsw: 0, - ru_nivcsw: 0, - } - } + pub struct CreateWebRtcServerRequest { + /// The field `web_rtc_server_id` in the table `CreateWebRtcServerRequest` + pub web_rtc_server_id: ::planus::alloc::string::String, + /// The field `listen_infos` in the table `CreateWebRtcServerRequest` + pub listen_infos: + ::core::option::Option<::planus::alloc::vec::Vec>, } - impl ResourceUsageResponse { - /// Creates a [ResourceUsageResponseBuilder] for serializing an instance of this table. + impl CreateWebRtcServerRequest { + /// Creates a [CreateWebRtcServerRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ResourceUsageResponseBuilder<()> { - ResourceUsageResponseBuilder(()) + pub fn builder() -> CreateWebRtcServerRequestBuilder<()> { + CreateWebRtcServerRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ru_utime: impl ::planus::WriteAsDefault, - field_ru_stime: impl ::planus::WriteAsDefault, - field_ru_maxrss: impl ::planus::WriteAsDefault, - field_ru_ixrss: impl ::planus::WriteAsDefault, - field_ru_idrss: impl ::planus::WriteAsDefault, - field_ru_isrss: impl ::planus::WriteAsDefault, - field_ru_minflt: impl ::planus::WriteAsDefault, - field_ru_majflt: impl ::planus::WriteAsDefault, - field_ru_nswap: impl ::planus::WriteAsDefault, - field_ru_inblock: impl ::planus::WriteAsDefault, - field_ru_oublock: impl ::planus::WriteAsDefault, - field_ru_msgsnd: impl ::planus::WriteAsDefault, - field_ru_msgrcv: impl ::planus::WriteAsDefault, - field_ru_nsignals: impl ::planus::WriteAsDefault, - field_ru_nvcsw: impl ::planus::WriteAsDefault, - field_ru_nivcsw: impl ::planus::WriteAsDefault, + field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, + field_listen_infos: impl ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, ) -> ::planus::Offset { - let prepared_ru_utime = field_ru_utime.prepare(builder, &0); - let prepared_ru_stime = field_ru_stime.prepare(builder, &0); - let prepared_ru_maxrss = field_ru_maxrss.prepare(builder, &0); - let prepared_ru_ixrss = field_ru_ixrss.prepare(builder, &0); - let prepared_ru_idrss = field_ru_idrss.prepare(builder, &0); - let prepared_ru_isrss = field_ru_isrss.prepare(builder, &0); - let prepared_ru_minflt = field_ru_minflt.prepare(builder, &0); - let prepared_ru_majflt = field_ru_majflt.prepare(builder, &0); - let prepared_ru_nswap = field_ru_nswap.prepare(builder, &0); - let prepared_ru_inblock = field_ru_inblock.prepare(builder, &0); - let prepared_ru_oublock = field_ru_oublock.prepare(builder, &0); - let prepared_ru_msgsnd = field_ru_msgsnd.prepare(builder, &0); - let prepared_ru_msgrcv = field_ru_msgrcv.prepare(builder, &0); - let prepared_ru_nsignals = field_ru_nsignals.prepare(builder, &0); - let prepared_ru_nvcsw = field_ru_nvcsw.prepare(builder, &0); - let prepared_ru_nivcsw = field_ru_nivcsw.prepare(builder, &0); + let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); + let prepared_listen_infos = field_listen_infos.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<36> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - if prepared_ru_utime.is_some() { - table_writer.write_entry::(0); - } - if prepared_ru_stime.is_some() { - table_writer.write_entry::(1); - } - if prepared_ru_maxrss.is_some() { - table_writer.write_entry::(2); - } - if prepared_ru_ixrss.is_some() { - table_writer.write_entry::(3); - } - if prepared_ru_idrss.is_some() { - table_writer.write_entry::(4); - } - if prepared_ru_isrss.is_some() { - table_writer.write_entry::(5); - } - if prepared_ru_minflt.is_some() { - table_writer.write_entry::(6); - } - if prepared_ru_majflt.is_some() { - table_writer.write_entry::(7); - } - if prepared_ru_nswap.is_some() { - table_writer.write_entry::(8); - } - if prepared_ru_inblock.is_some() { - table_writer.write_entry::(9); - } - if prepared_ru_oublock.is_some() { - table_writer.write_entry::(10); - } - if prepared_ru_msgsnd.is_some() { - table_writer.write_entry::(11); - } - if prepared_ru_msgrcv.is_some() { - table_writer.write_entry::(12); - } - if prepared_ru_nsignals.is_some() { - table_writer.write_entry::(13); - } - if prepared_ru_nvcsw.is_some() { - table_writer.write_entry::(14); - } - if prepared_ru_nivcsw.is_some() { - table_writer.write_entry::(15); + table_writer.write_entry::<::planus::Offset>(0); + if prepared_listen_infos.is_some() { + table_writer.write_entry::<::planus::Offset< + [::planus::Offset], + >>(1); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_ru_utime) = - prepared_ru_utime - { - object_writer.write::<_, _, 8>(&prepared_ru_utime); - } - if let ::core::option::Option::Some(prepared_ru_stime) = - prepared_ru_stime - { - object_writer.write::<_, _, 8>(&prepared_ru_stime); - } - if let ::core::option::Option::Some(prepared_ru_maxrss) = - prepared_ru_maxrss - { - object_writer.write::<_, _, 8>(&prepared_ru_maxrss); - } - if let ::core::option::Option::Some(prepared_ru_ixrss) = - prepared_ru_ixrss - { - object_writer.write::<_, _, 8>(&prepared_ru_ixrss); - } - if let ::core::option::Option::Some(prepared_ru_idrss) = - prepared_ru_idrss - { - object_writer.write::<_, _, 8>(&prepared_ru_idrss); - } - if let ::core::option::Option::Some(prepared_ru_isrss) = - prepared_ru_isrss - { - object_writer.write::<_, _, 8>(&prepared_ru_isrss); - } - if let ::core::option::Option::Some(prepared_ru_minflt) = - prepared_ru_minflt - { - object_writer.write::<_, _, 8>(&prepared_ru_minflt); - } - if let ::core::option::Option::Some(prepared_ru_majflt) = - prepared_ru_majflt - { - object_writer.write::<_, _, 8>(&prepared_ru_majflt); - } - if let ::core::option::Option::Some(prepared_ru_nswap) = - prepared_ru_nswap - { - object_writer.write::<_, _, 8>(&prepared_ru_nswap); - } - if let ::core::option::Option::Some(prepared_ru_inblock) = - prepared_ru_inblock - { - object_writer.write::<_, _, 8>(&prepared_ru_inblock); - } - if let ::core::option::Option::Some(prepared_ru_oublock) = - prepared_ru_oublock - { - object_writer.write::<_, _, 8>(&prepared_ru_oublock); - } - if let ::core::option::Option::Some(prepared_ru_msgsnd) = - prepared_ru_msgsnd - { - object_writer.write::<_, _, 8>(&prepared_ru_msgsnd); - } - if let ::core::option::Option::Some(prepared_ru_msgrcv) = - prepared_ru_msgrcv - { - object_writer.write::<_, _, 8>(&prepared_ru_msgrcv); - } - if let ::core::option::Option::Some(prepared_ru_nsignals) = - prepared_ru_nsignals - { - object_writer.write::<_, _, 8>(&prepared_ru_nsignals); - } - if let ::core::option::Option::Some(prepared_ru_nvcsw) = - prepared_ru_nvcsw - { - object_writer.write::<_, _, 8>(&prepared_ru_nvcsw); - } - if let ::core::option::Option::Some(prepared_ru_nivcsw) = - prepared_ru_nivcsw + object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); + if let ::core::option::Option::Some(prepared_listen_infos) = + prepared_listen_infos { - object_writer.write::<_, _, 8>(&prepared_ru_nivcsw); + object_writer.write::<_, _, 4>(&prepared_listen_infos); } }); } @@ -57145,1108 +59007,1027 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for ResourceUsageResponse { + impl ::planus::WriteAs<::planus::Offset> for CreateWebRtcServerRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for ResourceUsageResponse { + impl ::planus::WriteAsOptional<::planus::Offset> + for CreateWebRtcServerRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> + { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + } + } + + impl ::planus::WriteAsOffset for CreateWebRtcServerRequest { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + CreateWebRtcServerRequest::create( + builder, + &self.web_rtc_server_id, + &self.listen_infos, + ) + } + } + + /// Builder for serializing an instance of the [CreateWebRtcServerRequest] type. + /// + /// Can be created using the [CreateWebRtcServerRequest::builder] method. + #[derive(Debug)] + #[must_use] + pub struct CreateWebRtcServerRequestBuilder(State); + + impl CreateWebRtcServerRequestBuilder<()> { + /// Setter for the [`web_rtc_server_id` field](CreateWebRtcServerRequest#structfield.web_rtc_server_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn web_rtc_server_id( + self, + value: T0, + ) -> CreateWebRtcServerRequestBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + CreateWebRtcServerRequestBuilder((value,)) + } + } + + impl CreateWebRtcServerRequestBuilder<(T0,)> { + /// Setter for the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos). + #[inline] + #[allow(clippy::type_complexity)] + pub fn listen_infos( + self, + value: T1, + ) -> CreateWebRtcServerRequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0,) = self.0; + CreateWebRtcServerRequestBuilder((v0, value)) + } + + /// Sets the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn listen_infos_as_null(self) -> CreateWebRtcServerRequestBuilder<(T0, ())> { + self.listen_infos(()) + } + } + + impl CreateWebRtcServerRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateWebRtcServerRequest]. + #[inline] + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) + } + } + + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAs<::planus::Offset> + for CreateWebRtcServerRequestBuilder<(T0, T1)> + { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) + } + } + + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for CreateWebRtcServerRequestBuilder<(T0, T1)> + { + type Prepared = ::planus::Offset; + + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for ResourceUsageResponse { + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOffset + for CreateWebRtcServerRequestBuilder<(T0, T1)> + { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ResourceUsageResponse::create( - builder, - self.ru_utime, - self.ru_stime, - self.ru_maxrss, - self.ru_ixrss, - self.ru_idrss, - self.ru_isrss, - self.ru_minflt, - self.ru_majflt, - self.ru_nswap, - self.ru_inblock, - self.ru_oublock, - self.ru_msgsnd, - self.ru_msgrcv, - self.ru_nsignals, - self.ru_nvcsw, - self.ru_nivcsw, - ) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + CreateWebRtcServerRequest::create(builder, v0, v1) } } - /// Builder for serializing an instance of the [ResourceUsageResponse] type. - /// - /// Can be created using the [ResourceUsageResponse::builder] method. - #[derive(Debug)] - #[must_use] - pub struct ResourceUsageResponseBuilder(State); + /// Reference to a deserialized [CreateWebRtcServerRequest]. + #[derive(Copy, Clone)] + pub struct CreateWebRtcServerRequestRef<'a>(::planus::table_reader::Table<'a>); - impl ResourceUsageResponseBuilder<()> { - /// Setter for the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime). + impl<'a> CreateWebRtcServerRequestRef<'a> { + /// Getter for the [`web_rtc_server_id` field](CreateWebRtcServerRequest#structfield.web_rtc_server_id). #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_utime(self, value: T0) -> ResourceUsageResponseBuilder<(T0,)> - where - T0: ::planus::WriteAsDefault, - { - ResourceUsageResponseBuilder((value,)) + pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "CreateWebRtcServerRequest", "web_rtc_server_id") } - /// Sets the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime) to the default value. + /// Getter for the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos). #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_utime_as_default( - self, - ) -> ResourceUsageResponseBuilder<(::planus::DefaultValue,)> { - self.ru_utime(::planus::DefaultValue) + pub fn listen_infos( + &self, + ) -> ::planus::Result< + ::core::option::Option< + ::planus::Vector<'a, ::planus::Result>>, + >, + > { + self.0 + .access(1, "CreateWebRtcServerRequest", "listen_infos") } } - impl ResourceUsageResponseBuilder<(T0,)> { - /// Setter for the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_stime(self, value: T1) -> ResourceUsageResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault, - { - let (v0,) = self.0; - ResourceUsageResponseBuilder((v0, value)) + impl<'a> ::core::fmt::Debug for CreateWebRtcServerRequestRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("CreateWebRtcServerRequestRef"); + f.field("web_rtc_server_id", &self.web_rtc_server_id()); + if let ::core::option::Option::Some(field_listen_infos) = + self.listen_infos().transpose() + { + f.field("listen_infos", &field_listen_infos); + } + f.finish() } + } - /// Sets the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_stime_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, ::planus::DefaultValue)> { - self.ru_stime(::planus::DefaultValue) + impl<'a> ::core::convert::TryFrom> for CreateWebRtcServerRequest { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: CreateWebRtcServerRequestRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + web_rtc_server_id: ::core::convert::TryInto::try_into( + value.web_rtc_server_id()?, + )?, + listen_infos: if let ::core::option::Option::Some(listen_infos) = + value.listen_infos()? + { + ::core::option::Option::Some(listen_infos.to_vec_result()?) + } else { + ::core::option::Option::None + }, + }) } } - impl ResourceUsageResponseBuilder<(T0, T1)> { - /// Setter for the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss). + impl<'a> ::planus::TableRead<'a> for CreateWebRtcServerRequestRef<'a> { #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_maxrss(self, value: T2) -> ResourceUsageResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsDefault, - { - let (v0, v1) = self.0; - ResourceUsageResponseBuilder((v0, v1, value)) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } + } - /// Sets the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_maxrss_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, T1, ::planus::DefaultValue)> - { - self.ru_maxrss(::planus::DefaultValue) + impl<'a> ::planus::VectorReadInner<'a> for CreateWebRtcServerRequestRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[CreateWebRtcServerRequestRef]", + "get", + buffer.offset_from_start, + ) + }) } } - impl ResourceUsageResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss). + impl ::planus::VectorWrite<::planus::Offset> + for CreateWebRtcServerRequest + { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_ixrss( - self, - value: T3, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAsDefault, - { - let (v0, v1, v2) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, value)) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - /// Sets the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_ixrss_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, ::planus::DefaultValue)> - { - self.ru_ixrss(::planus::DefaultValue) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl ResourceUsageResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_idrss( - self, - value: T4, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4)> - where - T4: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, value)) + impl<'a> ::planus::ReadAsRoot<'a> for CreateWebRtcServerRequestRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location( + "[CreateWebRtcServerRequestRef]", + "read_as_root", + 0, + ) + }) } + } - /// Sets the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_idrss_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> - { - self.ru_idrss(::planus::DefaultValue) - } + /// The table `CloseWebRtcServerRequest` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `CloseWebRtcServerRequest` in the file `../worker/fbs/worker.fbs:46` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct CloseWebRtcServerRequest { + /// The field `web_rtc_server_id` in the table `CloseWebRtcServerRequest` + pub web_rtc_server_id: ::planus::alloc::string::String, } - impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss). + impl CloseWebRtcServerRequest { + /// Creates a [CloseWebRtcServerRequestBuilder] for serializing an instance of this table. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_isrss( - self, - value: T5, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5)> - where - T5: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, value)) + pub fn builder() -> CloseWebRtcServerRequestBuilder<()> { + CloseWebRtcServerRequestBuilder(()) } - /// Sets the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_isrss_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)> - { - self.ru_isrss(::planus::DefaultValue) + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, + ) -> ::planus::Offset { + let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<6> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); + }); + } + builder.current_offset() } } - impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Setter for the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_minflt( - self, - value: T6, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> - where - T6: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, value)) - } + impl ::planus::WriteAs<::planus::Offset> for CloseWebRtcServerRequest { + type Prepared = ::planus::Offset; - /// Sets the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_minflt_as_default( - self, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)> - { - self.ru_minflt(::planus::DefaultValue) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - /// Setter for the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt). + impl ::planus::WriteAsOptional<::planus::Offset> + for CloseWebRtcServerRequest + { + type Prepared = ::planus::Offset; + #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_majflt( - self, - value: T7, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> - where - T7: ::planus::WriteAsDefault, + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { - let (v0, v1, v2, v3, v4, v5, v6) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Sets the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt) to the default value. + impl ::planus::WriteAsOffset for CloseWebRtcServerRequest { #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_majflt_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - ::planus::DefaultValue, - )> { - self.ru_majflt(::planus::DefaultValue) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + CloseWebRtcServerRequest::create(builder, &self.web_rtc_server_id) } } - impl - ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> - { - /// Setter for the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap). + /// Builder for serializing an instance of the [CloseWebRtcServerRequest] type. + /// + /// Can be created using the [CloseWebRtcServerRequest::builder] method. + #[derive(Debug)] + #[must_use] + pub struct CloseWebRtcServerRequestBuilder(State); + + impl CloseWebRtcServerRequestBuilder<()> { + /// Setter for the [`web_rtc_server_id` field](CloseWebRtcServerRequest#structfield.web_rtc_server_id). #[inline] #[allow(clippy::type_complexity)] - pub fn ru_nswap( + pub fn web_rtc_server_id( self, - value: T8, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + value: T0, + ) -> CloseWebRtcServerRequestBuilder<(T0,)> where - T8: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value)) - } - - /// Sets the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nswap_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - ::planus::DefaultValue, - )> { - self.ru_nswap(::planus::DefaultValue) + CloseWebRtcServerRequestBuilder((value,)) } } - impl - ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> - { - /// Setter for the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock). + impl CloseWebRtcServerRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseWebRtcServerRequest]. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_inblock( + pub fn finish( self, - value: T9, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + builder: &mut ::planus::Builder, + ) -> ::planus::Offset where - T9: ::planus::WriteAsDefault, + Self: ::planus::WriteAsOffset, { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, value)) + ::planus::WriteAsOffset::prepare(&self, builder) } + } + + impl>> + ::planus::WriteAs<::planus::Offset> + for CloseWebRtcServerRequestBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// Sets the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_inblock_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - ::planus::DefaultValue, - )> { - self.ru_inblock(::planus::DefaultValue) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl - ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for CloseWebRtcServerRequestBuilder<(T0,)> { - /// Setter for the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock). + type Prepared = ::planus::Offset; + #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_oublock( - self, - value: T10, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> - where - T10: ::planus::WriteAsDefault, + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) = self.0; - ResourceUsageResponseBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, value)) + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Sets the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock) to the default value. + impl>> + ::planus::WriteAsOffset + for CloseWebRtcServerRequestBuilder<(T0,)> + { #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_oublock_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - ::planus::DefaultValue, - )> { - self.ru_oublock(::planus::DefaultValue) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + CloseWebRtcServerRequest::create(builder, v0) + } + } + + /// Reference to a deserialized [CloseWebRtcServerRequest]. + #[derive(Copy, Clone)] + pub struct CloseWebRtcServerRequestRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> CloseWebRtcServerRequestRef<'a> { + /// Getter for the [`web_rtc_server_id` field](CloseWebRtcServerRequest#structfield.web_rtc_server_id). + #[inline] + pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "CloseWebRtcServerRequest", "web_rtc_server_id") } } - impl - ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> - { - /// Setter for the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_msgsnd( - self, - value: T11, - ) -> ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> - where - T11: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = self.0; - ResourceUsageResponseBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, value, - )) + impl<'a> ::core::fmt::Debug for CloseWebRtcServerRequestRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("CloseWebRtcServerRequestRef"); + f.field("web_rtc_server_id", &self.web_rtc_server_id()); + f.finish() } + } - /// Sets the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_msgsnd_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - ::planus::DefaultValue, - )> { - self.ru_msgsnd(::planus::DefaultValue) + impl<'a> ::core::convert::TryFrom> for CloseWebRtcServerRequest { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: CloseWebRtcServerRequestRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + web_rtc_server_id: ::core::convert::TryInto::try_into( + value.web_rtc_server_id()?, + )?, + }) } } - impl - ResourceUsageResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> - { - /// Setter for the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv). + impl<'a> ::planus::TableRead<'a> for CloseWebRtcServerRequestRef<'a> { #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_msgrcv( - self, - value: T12, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - )> - where - T12: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) = self.0; - ResourceUsageResponseBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, value, - )) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } + } - /// Sets the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_msgrcv_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - ::planus::DefaultValue, - )> { - self.ru_msgrcv(::planus::DefaultValue) + impl<'a> ::planus::VectorReadInner<'a> for CloseWebRtcServerRequestRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[CloseWebRtcServerRequestRef]", + "get", + buffer.offset_from_start, + ) + }) } } - impl - ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - )> + impl ::planus::VectorWrite<::planus::Offset> + for CloseWebRtcServerRequest { - /// Setter for the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals). + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nsignals( - self, - value: T13, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - )> - where - T13: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) = self.0; - ResourceUsageResponseBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, value, - )) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - /// Sets the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nsignals_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - ::planus::DefaultValue, - )> { - self.ru_nsignals(::planus::DefaultValue) + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } } } - impl - ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - )> - { - /// Setter for the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nvcsw( - self, - value: T14, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - )> - where - T14: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) = self.0; - ResourceUsageResponseBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, value, - )) + impl<'a> ::planus::ReadAsRoot<'a> for CloseWebRtcServerRequestRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location( + "[CloseWebRtcServerRequestRef]", + "read_as_root", + 0, + ) + }) } + } - /// Sets the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw) to the default value. + /// The table `CreateRouterRequest` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `CreateRouterRequest` in the file `../worker/fbs/worker.fbs:50` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct CreateRouterRequest { + /// The field `router_id` in the table `CreateRouterRequest` + pub router_id: ::planus::alloc::string::String, + } + + impl CreateRouterRequest { + /// Creates a [CreateRouterRequestBuilder] for serializing an instance of this table. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nvcsw_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - ::planus::DefaultValue, - )> { - self.ru_nvcsw(::planus::DefaultValue) + pub fn builder() -> CreateRouterRequestBuilder<()> { + CreateRouterRequestBuilder(()) + } + + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_router_id: impl ::planus::WriteAs<::planus::Offset>, + ) -> ::planus::Offset { + let prepared_router_id = field_router_id.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<6> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_router_id); + }); + } + builder.current_offset() } } - impl - ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - )> - { - /// Setter for the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw). + impl ::planus::WriteAs<::planus::Offset> for CreateRouterRequest { + type Prepared = ::planus::Offset; + #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nivcsw( - self, - value: T15, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - )> - where - T15: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) = self.0; - ResourceUsageResponseBuilder(( - v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, value, - )) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } + + impl ::planus::WriteAsOptional<::planus::Offset> for CreateRouterRequest { + type Prepared = ::planus::Offset; - /// Sets the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ru_nivcsw_as_default( - self, - ) -> ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - ::planus::DefaultValue, - )> { - self.ru_nivcsw(::planus::DefaultValue) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl - ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - )> - { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ResourceUsageResponse]. + impl ::planus::WriteAsOffset for CreateRouterRequest { #[inline] - pub fn finish( - self, + fn prepare( + &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) + ) -> ::planus::Offset { + CreateRouterRequest::create(builder, &self.router_id) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsDefault, - T7: ::planus::WriteAsDefault, - T8: ::planus::WriteAsDefault, - T9: ::planus::WriteAsDefault, - T10: ::planus::WriteAsDefault, - T11: ::planus::WriteAsDefault, - T12: ::planus::WriteAsDefault, - T13: ::planus::WriteAsDefault, - T14: ::planus::WriteAsDefault, - T15: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> - for ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - )> + /// Builder for serializing an instance of the [CreateRouterRequest] type. + /// + /// Can be created using the [CreateRouterRequest::builder] method. + #[derive(Debug)] + #[must_use] + pub struct CreateRouterRequestBuilder(State); + + impl CreateRouterRequestBuilder<()> { + /// Setter for the [`router_id` field](CreateRouterRequest#structfield.router_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn router_id(self, value: T0) -> CreateRouterRequestBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + CreateRouterRequestBuilder((value,)) + } + } + + impl CreateRouterRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateRouterRequest]. + #[inline] + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) + } + } + + impl>> + ::planus::WriteAs<::planus::Offset> + for CreateRouterRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsDefault, - T7: ::planus::WriteAsDefault, - T8: ::planus::WriteAsDefault, - T9: ::planus::WriteAsDefault, - T10: ::planus::WriteAsDefault, - T11: ::planus::WriteAsDefault, - T12: ::planus::WriteAsDefault, - T13: ::planus::WriteAsDefault, - T14: ::planus::WriteAsDefault, - T15: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> - for ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - )> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for CreateRouterRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsDefault, - T7: ::planus::WriteAsDefault, - T8: ::planus::WriteAsDefault, - T9: ::planus::WriteAsDefault, - T10: ::planus::WriteAsDefault, - T11: ::planus::WriteAsDefault, - T12: ::planus::WriteAsDefault, - T13: ::planus::WriteAsDefault, - T14: ::planus::WriteAsDefault, - T15: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset - for ResourceUsageResponseBuilder<( - T0, - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - )> + impl>> + ::planus::WriteAsOffset for CreateRouterRequestBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) = - &self.0; - ResourceUsageResponse::create( - builder, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, - v15, - ) + ) -> ::planus::Offset { + let (v0,) = &self.0; + CreateRouterRequest::create(builder, v0) } } - /// Reference to a deserialized [ResourceUsageResponse]. + /// Reference to a deserialized [CreateRouterRequest]. #[derive(Copy, Clone)] - pub struct ResourceUsageResponseRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreateRouterRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> ResourceUsageResponseRef<'a> { - /// Getter for the [`ru_utime` field](ResourceUsageResponse#structfield.ru_utime). + impl<'a> CreateRouterRequestRef<'a> { + /// Getter for the [`router_id` field](CreateRouterRequest#structfield.router_id). #[inline] - pub fn ru_utime(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(0, "ResourceUsageResponse", "ru_utime")? - .unwrap_or(0), - ) + pub fn router_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "CreateRouterRequest", "router_id") } + } - /// Getter for the [`ru_stime` field](ResourceUsageResponse#structfield.ru_stime). - #[inline] - pub fn ru_stime(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "ResourceUsageResponse", "ru_stime")? - .unwrap_or(0), - ) + impl<'a> ::core::fmt::Debug for CreateRouterRequestRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("CreateRouterRequestRef"); + f.field("router_id", &self.router_id()); + f.finish() } + } - /// Getter for the [`ru_maxrss` field](ResourceUsageResponse#structfield.ru_maxrss). - #[inline] - pub fn ru_maxrss(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "ResourceUsageResponse", "ru_maxrss")? - .unwrap_or(0), - ) + impl<'a> ::core::convert::TryFrom> for CreateRouterRequest { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: CreateRouterRequestRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + router_id: ::core::convert::TryInto::try_into(value.router_id()?)?, + }) } + } - /// Getter for the [`ru_ixrss` field](ResourceUsageResponse#structfield.ru_ixrss). + impl<'a> ::planus::TableRead<'a> for CreateRouterRequestRef<'a> { #[inline] - pub fn ru_ixrss(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(3, "ResourceUsageResponse", "ru_ixrss")? - .unwrap_or(0), - ) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::core::result::Result { + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } + } - /// Getter for the [`ru_idrss` field](ResourceUsageResponse#structfield.ru_idrss). + impl<'a> ::planus::VectorReadInner<'a> for CreateRouterRequestRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[CreateRouterRequestRef]", + "get", + buffer.offset_from_start, + ) + }) + } + } + + impl ::planus::VectorWrite<::planus::Offset> for CreateRouterRequest { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - pub fn ru_idrss(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(4, "ResourceUsageResponse", "ru_idrss")? - .unwrap_or(0), - ) + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } - /// Getter for the [`ru_isrss` field](ResourceUsageResponse#structfield.ru_isrss). #[inline] - pub fn ru_isrss(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(5, "ResourceUsageResponse", "ru_isrss")? - .unwrap_or(0), + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); + } + } + } + + impl<'a> ::planus::ReadAsRoot<'a> for CreateRouterRequestRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, ) + .map_err(|error_kind| { + error_kind.with_error_location( + "[CreateRouterRequestRef]", + "read_as_root", + 0, + ) + }) } + } - /// Getter for the [`ru_minflt` field](ResourceUsageResponse#structfield.ru_minflt). + /// The table `CloseRouterRequest` in the namespace `FBS.Worker` + /// + /// Generated from these locations: + /// * Table `CloseRouterRequest` in the file `../worker/fbs/worker.fbs:54` + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct CloseRouterRequest { + /// The field `router_id` in the table `CloseRouterRequest` + pub router_id: ::planus::alloc::string::String, + } + + impl CloseRouterRequest { + /// Creates a [CloseRouterRequestBuilder] for serializing an instance of this table. #[inline] - pub fn ru_minflt(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(6, "ResourceUsageResponse", "ru_minflt")? - .unwrap_or(0), - ) + pub fn builder() -> CloseRouterRequestBuilder<()> { + CloseRouterRequestBuilder(()) } - /// Getter for the [`ru_majflt` field](ResourceUsageResponse#structfield.ru_majflt). + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_router_id: impl ::planus::WriteAs<::planus::Offset>, + ) -> ::planus::Offset { + let prepared_router_id = field_router_id.prepare(builder); + + let mut table_writer: ::planus::table_writer::TableWriter<6> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); + + unsafe { + table_writer.finish(builder, |object_writer| { + object_writer.write::<_, _, 4>(&prepared_router_id); + }); + } + builder.current_offset() + } + } + + impl ::planus::WriteAs<::planus::Offset> for CloseRouterRequest { + type Prepared = ::planus::Offset; + #[inline] - pub fn ru_majflt(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(7, "ResourceUsageResponse", "ru_majflt")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } + + impl ::planus::WriteAsOptional<::planus::Offset> for CloseRouterRequest { + type Prepared = ::planus::Offset; - /// Getter for the [`ru_nswap` field](ResourceUsageResponse#structfield.ru_nswap). #[inline] - pub fn ru_nswap(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(8, "ResourceUsageResponse", "ru_nswap")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Getter for the [`ru_inblock` field](ResourceUsageResponse#structfield.ru_inblock). + impl ::planus::WriteAsOffset for CloseRouterRequest { #[inline] - pub fn ru_inblock(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(9, "ResourceUsageResponse", "ru_inblock")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + CloseRouterRequest::create(builder, &self.router_id) } + } - /// Getter for the [`ru_oublock` field](ResourceUsageResponse#structfield.ru_oublock). + /// Builder for serializing an instance of the [CloseRouterRequest] type. + /// + /// Can be created using the [CloseRouterRequest::builder] method. + #[derive(Debug)] + #[must_use] + pub struct CloseRouterRequestBuilder(State); + + impl CloseRouterRequestBuilder<()> { + /// Setter for the [`router_id` field](CloseRouterRequest#structfield.router_id). #[inline] - pub fn ru_oublock(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(10, "ResourceUsageResponse", "ru_oublock")? - .unwrap_or(0), - ) + #[allow(clippy::type_complexity)] + pub fn router_id(self, value: T0) -> CloseRouterRequestBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + CloseRouterRequestBuilder((value,)) } + } - /// Getter for the [`ru_msgsnd` field](ResourceUsageResponse#structfield.ru_msgsnd). + impl CloseRouterRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseRouterRequest]. #[inline] - pub fn ru_msgsnd(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(11, "ResourceUsageResponse", "ru_msgsnd")? - .unwrap_or(0), - ) + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } + } + + impl>> + ::planus::WriteAs<::planus::Offset> + for CloseRouterRequestBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// Getter for the [`ru_msgrcv` field](ResourceUsageResponse#structfield.ru_msgrcv). #[inline] - pub fn ru_msgrcv(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(12, "ResourceUsageResponse", "ru_msgrcv")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } + + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for CloseRouterRequestBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// Getter for the [`ru_nsignals` field](ResourceUsageResponse#structfield.ru_nsignals). #[inline] - pub fn ru_nsignals(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(13, "ResourceUsageResponse", "ru_nsignals")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Getter for the [`ru_nvcsw` field](ResourceUsageResponse#structfield.ru_nvcsw). + impl>> + ::planus::WriteAsOffset for CloseRouterRequestBuilder<(T0,)> + { #[inline] - pub fn ru_nvcsw(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(14, "ResourceUsageResponse", "ru_nvcsw")? - .unwrap_or(0), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + CloseRouterRequest::create(builder, v0) } + } - /// Getter for the [`ru_nivcsw` field](ResourceUsageResponse#structfield.ru_nivcsw). + /// Reference to a deserialized [CloseRouterRequest]. + #[derive(Copy, Clone)] + pub struct CloseRouterRequestRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> CloseRouterRequestRef<'a> { + /// Getter for the [`router_id` field](CloseRouterRequest#structfield.router_id). #[inline] - pub fn ru_nivcsw(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(15, "ResourceUsageResponse", "ru_nivcsw")? - .unwrap_or(0), - ) + pub fn router_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "CloseRouterRequest", "router_id") } } - impl<'a> ::core::fmt::Debug for ResourceUsageResponseRef<'a> { + impl<'a> ::core::fmt::Debug for CloseRouterRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ResourceUsageResponseRef"); - f.field("ru_utime", &self.ru_utime()); - f.field("ru_stime", &self.ru_stime()); - f.field("ru_maxrss", &self.ru_maxrss()); - f.field("ru_ixrss", &self.ru_ixrss()); - f.field("ru_idrss", &self.ru_idrss()); - f.field("ru_isrss", &self.ru_isrss()); - f.field("ru_minflt", &self.ru_minflt()); - f.field("ru_majflt", &self.ru_majflt()); - f.field("ru_nswap", &self.ru_nswap()); - f.field("ru_inblock", &self.ru_inblock()); - f.field("ru_oublock", &self.ru_oublock()); - f.field("ru_msgsnd", &self.ru_msgsnd()); - f.field("ru_msgrcv", &self.ru_msgrcv()); - f.field("ru_nsignals", &self.ru_nsignals()); - f.field("ru_nvcsw", &self.ru_nvcsw()); - f.field("ru_nivcsw", &self.ru_nivcsw()); + let mut f = f.debug_struct("CloseRouterRequestRef"); + f.field("router_id", &self.router_id()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ResourceUsageResponse { + impl<'a> ::core::convert::TryFrom> for CloseRouterRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ResourceUsageResponseRef<'a>) -> ::planus::Result { + fn try_from(value: CloseRouterRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ru_utime: ::core::convert::TryInto::try_into(value.ru_utime()?)?, - ru_stime: ::core::convert::TryInto::try_into(value.ru_stime()?)?, - ru_maxrss: ::core::convert::TryInto::try_into(value.ru_maxrss()?)?, - ru_ixrss: ::core::convert::TryInto::try_into(value.ru_ixrss()?)?, - ru_idrss: ::core::convert::TryInto::try_into(value.ru_idrss()?)?, - ru_isrss: ::core::convert::TryInto::try_into(value.ru_isrss()?)?, - ru_minflt: ::core::convert::TryInto::try_into(value.ru_minflt()?)?, - ru_majflt: ::core::convert::TryInto::try_into(value.ru_majflt()?)?, - ru_nswap: ::core::convert::TryInto::try_into(value.ru_nswap()?)?, - ru_inblock: ::core::convert::TryInto::try_into(value.ru_inblock()?)?, - ru_oublock: ::core::convert::TryInto::try_into(value.ru_oublock()?)?, - ru_msgsnd: ::core::convert::TryInto::try_into(value.ru_msgsnd()?)?, - ru_msgrcv: ::core::convert::TryInto::try_into(value.ru_msgrcv()?)?, - ru_nsignals: ::core::convert::TryInto::try_into(value.ru_nsignals()?)?, - ru_nvcsw: ::core::convert::TryInto::try_into(value.ru_nvcsw()?)?, - ru_nivcsw: ::core::convert::TryInto::try_into(value.ru_nivcsw()?)?, + router_id: ::core::convert::TryInto::try_into(value.router_id()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for ResourceUsageResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for CloseRouterRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -58258,7 +60039,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ResourceUsageResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CloseRouterRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -58268,7 +60049,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ResourceUsageResponseRef]", + "[CloseRouterRequestRef]", "get", buffer.offset_from_start, ) @@ -58276,8 +60057,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ResourceUsageResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for CloseRouterRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -58286,7 +60067,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -58301,7 +60082,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ResourceUsageResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CloseRouterRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -58311,19 +60092,20 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[ResourceUsageResponseRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[CloseRouterRequestRef]", "read_as_root", 0) }) } } - - /// The table `UpdateSettingsRequest` in the namespace `FBS.Worker` + } + /// The namespace `FBS.Router` + /// + /// Generated from these locations: + /// * File `../worker/fbs/router.fbs` + pub mod router { + /// The table `DumpResponse` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `UpdateSettingsRequest` in the file `../worker/fbs/worker.fbs:36` + /// * Table `DumpResponse` in the file `../worker/fbs/router.fbs:12` #[derive( Clone, Debug, @@ -58335,289 +60117,556 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct UpdateSettingsRequest { - /// The field `log_level` in the table `UpdateSettingsRequest` - pub log_level: ::core::option::Option<::planus::alloc::string::String>, - /// The field `log_tags` in the table `UpdateSettingsRequest` - pub log_tags: ::core::option::Option< - ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - >, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for UpdateSettingsRequest { - fn default() -> Self { - Self { - log_level: ::core::default::Default::default(), - log_tags: ::core::default::Default::default(), - } - } + pub struct DumpResponse { + /// The field `id` in the table `DumpResponse` + pub id: ::planus::alloc::string::String, + /// The field `transport_ids` in the table `DumpResponse` + pub transport_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `rtp_observer_ids` in the table `DumpResponse` + pub rtp_observer_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `map_producer_id_consumer_ids` in the table `DumpResponse` + pub map_producer_id_consumer_ids: + ::planus::alloc::vec::Vec, + /// The field `map_consumer_id_producer_id` in the table `DumpResponse` + pub map_consumer_id_producer_id: + ::planus::alloc::vec::Vec, + /// The field `map_producer_id_observer_ids` in the table `DumpResponse` + pub map_producer_id_observer_ids: + ::planus::alloc::vec::Vec, + /// The field `map_data_producer_id_data_consumer_ids` in the table `DumpResponse` + pub map_data_producer_id_data_consumer_ids: + ::planus::alloc::vec::Vec, + /// The field `map_data_consumer_id_data_producer_id` in the table `DumpResponse` + pub map_data_consumer_id_data_producer_id: + ::planus::alloc::vec::Vec, } - impl UpdateSettingsRequest { - /// Creates a [UpdateSettingsRequestBuilder] for serializing an instance of this table. + impl DumpResponse { + /// Creates a [DumpResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> UpdateSettingsRequestBuilder<()> { - UpdateSettingsRequestBuilder(()) + pub fn builder() -> DumpResponseBuilder<()> { + DumpResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_log_level: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, + field_id: impl ::planus::WriteAs<::planus::Offset>, + field_transport_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, >, - field_log_tags: impl ::planus::WriteAsOptional< + field_rtp_observer_ids: impl ::planus::WriteAs< ::planus::Offset<[::planus::Offset]>, >, + field_map_producer_id_consumer_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_map_consumer_id_producer_id: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_map_producer_id_observer_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_map_data_producer_id_data_consumer_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_map_data_consumer_id_data_producer_id: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, ) -> ::planus::Offset { - let prepared_log_level = field_log_level.prepare(builder); - let prepared_log_tags = field_log_tags.prepare(builder); + let prepared_id = field_id.prepare(builder); + let prepared_transport_ids = field_transport_ids.prepare(builder); + let prepared_rtp_observer_ids = field_rtp_observer_ids.prepare(builder); + let prepared_map_producer_id_consumer_ids = + field_map_producer_id_consumer_ids.prepare(builder); + let prepared_map_consumer_id_producer_id = + field_map_consumer_id_producer_id.prepare(builder); + let prepared_map_producer_id_observer_ids = + field_map_producer_id_observer_ids.prepare(builder); + let prepared_map_data_producer_id_data_consumer_ids = + field_map_data_producer_id_data_consumer_ids.prepare(builder); + let prepared_map_data_consumer_id_data_producer_id = + field_map_data_consumer_id_data_producer_id.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<20> = ::core::default::Default::default(); - if prepared_log_level.is_some() { - table_writer.write_entry::<::planus::Offset>(0); - } - if prepared_log_tags.is_some() { - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); - } + table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(2); + table_writer.write_entry::<::planus::Offset< + [::planus::Offset], + >>(3); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(4); + table_writer.write_entry::<::planus::Offset< + [::planus::Offset], + >>(5); + table_writer.write_entry::<::planus::Offset< + [::planus::Offset], + >>(6); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(7); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_log_level) = - prepared_log_level - { - object_writer.write::<_, _, 4>(&prepared_log_level); - } - if let ::core::option::Option::Some(prepared_log_tags) = - prepared_log_tags - { - object_writer.write::<_, _, 4>(&prepared_log_tags); - } + object_writer.write::<_, _, 4>(&prepared_id); + object_writer.write::<_, _, 4>(&prepared_transport_ids); + object_writer.write::<_, _, 4>(&prepared_rtp_observer_ids); + object_writer.write::<_, _, 4>(&prepared_map_producer_id_consumer_ids); + object_writer.write::<_, _, 4>(&prepared_map_consumer_id_producer_id); + object_writer.write::<_, _, 4>(&prepared_map_producer_id_observer_ids); + object_writer + .write::<_, _, 4>(&prepared_map_data_producer_id_data_consumer_ids); + object_writer + .write::<_, _, 4>(&prepared_map_data_consumer_id_data_producer_id); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for UpdateSettingsRequest { + impl ::planus::WriteAs<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for UpdateSettingsRequest { + impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for UpdateSettingsRequest { + impl ::planus::WriteAsOffset for DumpResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - UpdateSettingsRequest::create(builder, &self.log_level, &self.log_tags) + ) -> ::planus::Offset { + DumpResponse::create( + builder, + &self.id, + &self.transport_ids, + &self.rtp_observer_ids, + &self.map_producer_id_consumer_ids, + &self.map_consumer_id_producer_id, + &self.map_producer_id_observer_ids, + &self.map_data_producer_id_data_consumer_ids, + &self.map_data_consumer_id_data_producer_id, + ) } } - /// Builder for serializing an instance of the [UpdateSettingsRequest] type. + /// Builder for serializing an instance of the [DumpResponse] type. /// - /// Can be created using the [UpdateSettingsRequest::builder] method. + /// Can be created using the [DumpResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct UpdateSettingsRequestBuilder(State); + pub struct DumpResponseBuilder(State); - impl UpdateSettingsRequestBuilder<()> { - /// Setter for the [`log_level` field](UpdateSettingsRequest#structfield.log_level). + impl DumpResponseBuilder<()> { + /// Setter for the [`id` field](DumpResponse#structfield.id). #[inline] #[allow(clippy::type_complexity)] - pub fn log_level(self, value: T0) -> UpdateSettingsRequestBuilder<(T0,)> + pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> where - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T0: ::planus::WriteAs<::planus::Offset>, { - UpdateSettingsRequestBuilder((value,)) + DumpResponseBuilder((value,)) } + } - /// Sets the [`log_level` field](UpdateSettingsRequest#structfield.log_level) to null. + impl DumpResponseBuilder<(T0,)> { + /// Setter for the [`transport_ids` field](DumpResponse#structfield.transport_ids). #[inline] #[allow(clippy::type_complexity)] - pub fn log_level_as_null(self) -> UpdateSettingsRequestBuilder<((),)> { - self.log_level(()) + pub fn transport_ids(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0,) = self.0; + DumpResponseBuilder((v0, value)) } } - impl UpdateSettingsRequestBuilder<(T0,)> { - /// Setter for the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags). + impl DumpResponseBuilder<(T0, T1)> { + /// Setter for the [`rtp_observer_ids` field](DumpResponse#structfield.rtp_observer_ids). #[inline] #[allow(clippy::type_complexity)] - pub fn log_tags(self, value: T1) -> UpdateSettingsRequestBuilder<(T0, T1)> + pub fn rtp_observer_ids(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> where - T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, { - let (v0,) = self.0; - UpdateSettingsRequestBuilder((v0, value)) + let (v0, v1) = self.0; + DumpResponseBuilder((v0, v1, value)) } + } - /// Sets the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags) to null. + impl DumpResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`map_producer_id_consumer_ids` field](DumpResponse#structfield.map_producer_id_consumer_ids). #[inline] #[allow(clippy::type_complexity)] - pub fn log_tags_as_null(self) -> UpdateSettingsRequestBuilder<(T0, ())> { - self.log_tags(()) + pub fn map_producer_id_consumer_ids( + self, + value: T3, + ) -> DumpResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2) = self.0; + DumpResponseBuilder((v0, v1, v2, value)) } } - impl UpdateSettingsRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [UpdateSettingsRequest]. + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`map_consumer_id_producer_id` field](DumpResponse#structfield.map_consumer_id_producer_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn map_consumer_id_producer_id( + self, + value: T4, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`map_producer_id_observer_ids` field](DumpResponse#structfield.map_producer_id_observer_ids). + #[inline] + #[allow(clippy::type_complexity)] + pub fn map_producer_id_observer_ids( + self, + value: T5, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3, v4) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { + /// Setter for the [`map_data_producer_id_data_consumer_ids` field](DumpResponse#structfield.map_data_producer_id_data_consumer_ids). + #[inline] + #[allow(clippy::type_complexity)] + pub fn map_data_producer_id_data_consumer_ids( + self, + value: T6, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> + where + T6: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3, v4, v5) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, v5, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { + /// Setter for the [`map_data_consumer_id_data_producer_id` field](DumpResponse#structfield.map_data_consumer_id_data_producer_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn map_data_consumer_id_data_producer_id( + self, + value: T7, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + where + T7: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3, v4, v5, v6) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAs<::planus::Offset> - for UpdateSettingsRequestBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T7: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAs<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOptional<::planus::Offset> - for UpdateSettingsRequestBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T7: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOffset - for UpdateSettingsRequestBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T7: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOffset + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - UpdateSettingsRequest::create(builder, v0, v1) + ) -> ::planus::Offset { + let (v0, v1, v2, v3, v4, v5, v6, v7) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3, v4, v5, v6, v7) } } - /// Reference to a deserialized [UpdateSettingsRequest]. + /// Reference to a deserialized [DumpResponse]. #[derive(Copy, Clone)] - pub struct UpdateSettingsRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> UpdateSettingsRequestRef<'a> { - /// Getter for the [`log_level` field](UpdateSettingsRequest#structfield.log_level). + impl<'a> DumpResponseRef<'a> { + /// Getter for the [`id` field](DumpResponse#structfield.id). #[inline] - pub fn log_level( + pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "DumpResponse", "id") + } + + /// Getter for the [`transport_ids` field](DumpResponse#structfield.transport_ids). + #[inline] + pub fn transport_ids( &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(0, "UpdateSettingsRequest", "log_level") + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0.access_required(1, "DumpResponse", "transport_ids") } - /// Getter for the [`log_tags` field](UpdateSettingsRequest#structfield.log_tags). + /// Getter for the [`rtp_observer_ids` field](DumpResponse#structfield.rtp_observer_ids). #[inline] - pub fn log_tags( + pub fn rtp_observer_ids( &self, ) -> ::planus::Result< - ::core::option::Option< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - >, + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, > { - self.0.access(1, "UpdateSettingsRequest", "log_tags") + self.0 + .access_required(2, "DumpResponse", "rtp_observer_ids") + } + + /// Getter for the [`map_producer_id_consumer_ids` field](DumpResponse#structfield.map_producer_id_consumer_ids). + #[inline] + pub fn map_producer_id_consumer_ids( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0 + .access_required(3, "DumpResponse", "map_producer_id_consumer_ids") + } + + /// Getter for the [`map_consumer_id_producer_id` field](DumpResponse#structfield.map_consumer_id_producer_id). + #[inline] + pub fn map_consumer_id_producer_id( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0 + .access_required(4, "DumpResponse", "map_consumer_id_producer_id") + } + + /// Getter for the [`map_producer_id_observer_ids` field](DumpResponse#structfield.map_producer_id_observer_ids). + #[inline] + pub fn map_producer_id_observer_ids( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0 + .access_required(5, "DumpResponse", "map_producer_id_observer_ids") + } + + /// Getter for the [`map_data_producer_id_data_consumer_ids` field](DumpResponse#structfield.map_data_producer_id_data_consumer_ids). + #[inline] + pub fn map_data_producer_id_data_consumer_ids( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0.access_required( + 6, + "DumpResponse", + "map_data_producer_id_data_consumer_ids", + ) + } + + /// Getter for the [`map_data_consumer_id_data_producer_id` field](DumpResponse#structfield.map_data_consumer_id_data_producer_id). + #[inline] + pub fn map_data_consumer_id_data_producer_id( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0.access_required( + 7, + "DumpResponse", + "map_data_consumer_id_data_producer_id", + ) } } - impl<'a> ::core::fmt::Debug for UpdateSettingsRequestRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("UpdateSettingsRequestRef"); - if let ::core::option::Option::Some(field_log_level) = - self.log_level().transpose() - { - f.field("log_level", &field_log_level); - } - if let ::core::option::Option::Some(field_log_tags) = - self.log_tags().transpose() - { - f.field("log_tags", &field_log_tags); - } + impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("DumpResponseRef"); + f.field("id", &self.id()); + f.field("transport_ids", &self.transport_ids()); + f.field("rtp_observer_ids", &self.rtp_observer_ids()); + f.field( + "map_producer_id_consumer_ids", + &self.map_producer_id_consumer_ids(), + ); + f.field( + "map_consumer_id_producer_id", + &self.map_consumer_id_producer_id(), + ); + f.field( + "map_producer_id_observer_ids", + &self.map_producer_id_observer_ids(), + ); + f.field( + "map_data_producer_id_data_consumer_ids", + &self.map_data_producer_id_data_consumer_ids(), + ); + f.field( + "map_data_consumer_id_data_producer_id", + &self.map_data_consumer_id_data_producer_id(), + ); f.finish() } } - impl<'a> ::core::convert::TryFrom> for UpdateSettingsRequest { + impl<'a> ::core::convert::TryFrom> for DumpResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: UpdateSettingsRequestRef<'a>) -> ::planus::Result { + fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - log_level: if let ::core::option::Option::Some(log_level) = - value.log_level()? - { - ::core::option::Option::Some(::core::convert::TryInto::try_into( - log_level, - )?) - } else { - ::core::option::Option::None - }, - log_tags: if let ::core::option::Option::Some(log_tags) = - value.log_tags()? - { - ::core::option::Option::Some(log_tags.to_vec_result()?) - } else { - ::core::option::Option::None - }, + id: ::core::convert::TryInto::try_into(value.id()?)?, + transport_ids: value.transport_ids()?.to_vec_result()?, + rtp_observer_ids: value.rtp_observer_ids()?.to_vec_result()?, + map_producer_id_consumer_ids: value + .map_producer_id_consumer_ids()? + .to_vec_result()?, + map_consumer_id_producer_id: value + .map_consumer_id_producer_id()? + .to_vec_result()?, + map_producer_id_observer_ids: value + .map_producer_id_observer_ids()? + .to_vec_result()?, + map_data_producer_id_data_consumer_ids: value + .map_data_producer_id_data_consumer_ids()? + .to_vec_result()?, + map_data_consumer_id_data_producer_id: value + .map_data_consumer_id_data_producer_id()? + .to_vec_result()?, }) } } - impl<'a> ::planus::TableRead<'a> for UpdateSettingsRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -58629,7 +60678,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for UpdateSettingsRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -58639,7 +60688,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[UpdateSettingsRequestRef]", + "[DumpResponseRef]", "get", buffer.offset_from_start, ) @@ -58647,8 +60696,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for UpdateSettingsRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -58657,7 +60706,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -58672,7 +60721,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for UpdateSettingsRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -58682,19 +60731,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[UpdateSettingsRequestRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) }) } } - /// The table `CreateWebRtcServerRequest` in the namespace `FBS.Worker` + /// The table `CreatePipeTransportRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CreateWebRtcServerRequest` in the file `../worker/fbs/worker.fbs:41` + /// * Table `CreatePipeTransportRequest` in the file `../worker/fbs/router.fbs:23` #[derive( Clone, Debug, @@ -58706,69 +60751,63 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateWebRtcServerRequest { - /// The field `web_rtc_server_id` in the table `CreateWebRtcServerRequest` - pub web_rtc_server_id: ::planus::alloc::string::String, - /// The field `listen_infos` in the table `CreateWebRtcServerRequest` - pub listen_infos: - ::core::option::Option<::planus::alloc::vec::Vec>, + pub struct CreatePipeTransportRequest { + /// The field `transport_id` in the table `CreatePipeTransportRequest` + pub transport_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreatePipeTransportRequest` + pub options: + ::planus::alloc::boxed::Box, } - impl CreateWebRtcServerRequest { - /// Creates a [CreateWebRtcServerRequestBuilder] for serializing an instance of this table. + impl CreatePipeTransportRequest { + /// Creates a [CreatePipeTransportRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateWebRtcServerRequestBuilder<()> { - CreateWebRtcServerRequestBuilder(()) + pub fn builder() -> CreatePipeTransportRequestBuilder<()> { + CreatePipeTransportRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, - field_listen_infos: impl ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, + field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_options: impl ::planus::WriteAs< + ::planus::Offset, >, ) -> ::planus::Offset { - let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); - let prepared_listen_infos = field_listen_infos.prepare(builder); + let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_options = field_options.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - if prepared_listen_infos.is_some() { - table_writer.write_entry::<::planus::Offset< - [::planus::Offset], - >>(1); - } + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); - if let ::core::option::Option::Some(prepared_listen_infos) = - prepared_listen_infos - { - object_writer.write::<_, _, 4>(&prepared_listen_infos); - } + object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CreateWebRtcServerRequest { + impl ::planus::WriteAs<::planus::Offset> + for CreatePipeTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreateWebRtcServerRequest + impl ::planus::WriteAsOptional<::planus::Offset> + for CreatePipeTransportRequest { type Prepared = ::planus::Offset; @@ -58776,82 +60815,65 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreateWebRtcServerRequest { + impl ::planus::WriteAsOffset for CreatePipeTransportRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateWebRtcServerRequest::create( - builder, - &self.web_rtc_server_id, - &self.listen_infos, - ) + ) -> ::planus::Offset { + CreatePipeTransportRequest::create(builder, &self.transport_id, &self.options) } } - /// Builder for serializing an instance of the [CreateWebRtcServerRequest] type. + /// Builder for serializing an instance of the [CreatePipeTransportRequest] type. /// - /// Can be created using the [CreateWebRtcServerRequest::builder] method. + /// Can be created using the [CreatePipeTransportRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateWebRtcServerRequestBuilder(State); + pub struct CreatePipeTransportRequestBuilder(State); - impl CreateWebRtcServerRequestBuilder<()> { - /// Setter for the [`web_rtc_server_id` field](CreateWebRtcServerRequest#structfield.web_rtc_server_id). + impl CreatePipeTransportRequestBuilder<()> { + /// Setter for the [`transport_id` field](CreatePipeTransportRequest#structfield.transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_server_id( - self, - value: T0, - ) -> CreateWebRtcServerRequestBuilder<(T0,)> + pub fn transport_id(self, value: T0) -> CreatePipeTransportRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreateWebRtcServerRequestBuilder((value,)) + CreatePipeTransportRequestBuilder((value,)) } } - impl CreateWebRtcServerRequestBuilder<(T0,)> { - /// Setter for the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos). + impl CreatePipeTransportRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreatePipeTransportRequest#structfield.options). #[inline] #[allow(clippy::type_complexity)] - pub fn listen_infos( - self, - value: T1, - ) -> CreateWebRtcServerRequestBuilder<(T0, T1)> + pub fn options(self, value: T1) -> CreatePipeTransportRequestBuilder<(T0, T1)> where - T1: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, { let (v0,) = self.0; - CreateWebRtcServerRequestBuilder((v0, value)) - } - - /// Sets the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn listen_infos_as_null(self) -> CreateWebRtcServerRequestBuilder<(T0, ())> { - self.listen_infos(()) + CreatePipeTransportRequestBuilder((v0, value)) } } - impl CreateWebRtcServerRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateWebRtcServerRequest]. + impl CreatePipeTransportRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreatePipeTransportRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -58859,38 +60881,39 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAs<::planus::Offset> - for CreateWebRtcServerRequestBuilder<(T0, T1)> + > ::planus::WriteAs<::planus::Offset> + for CreatePipeTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAsOptional<::planus::Offset> - for CreateWebRtcServerRequestBuilder<(T0, T1)> + > + ::planus::WriteAsOptional<::planus::Offset> + for CreatePipeTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } @@ -58898,82 +60921,71 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAsOffset - for CreateWebRtcServerRequestBuilder<(T0, T1)> + > ::planus::WriteAsOffset + for CreatePipeTransportRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0, v1) = &self.0; - CreateWebRtcServerRequest::create(builder, v0, v1) + CreatePipeTransportRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [CreateWebRtcServerRequest]. + /// Reference to a deserialized [CreatePipeTransportRequest]. #[derive(Copy, Clone)] - pub struct CreateWebRtcServerRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreatePipeTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreateWebRtcServerRequestRef<'a> { - /// Getter for the [`web_rtc_server_id` field](CreateWebRtcServerRequest#structfield.web_rtc_server_id). + impl<'a> CreatePipeTransportRequestRef<'a> { + /// Getter for the [`transport_id` field](CreatePipeTransportRequest#structfield.transport_id). #[inline] - pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(0, "CreateWebRtcServerRequest", "web_rtc_server_id") + .access_required(0, "CreatePipeTransportRequest", "transport_id") } - /// Getter for the [`listen_infos` field](CreateWebRtcServerRequest#structfield.listen_infos). + /// Getter for the [`options` field](CreatePipeTransportRequest#structfield.options). #[inline] - pub fn listen_infos( + pub fn options( &self, - ) -> ::planus::Result< - ::core::option::Option< - ::planus::Vector<'a, ::planus::Result>>, - >, - > { + ) -> ::planus::Result> + { self.0 - .access(1, "CreateWebRtcServerRequest", "listen_infos") + .access_required(1, "CreatePipeTransportRequest", "options") } } - impl<'a> ::core::fmt::Debug for CreateWebRtcServerRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CreatePipeTransportRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateWebRtcServerRequestRef"); - f.field("web_rtc_server_id", &self.web_rtc_server_id()); - if let ::core::option::Option::Some(field_listen_infos) = - self.listen_infos().transpose() - { - f.field("listen_infos", &field_listen_infos); - } + let mut f = f.debug_struct("CreatePipeTransportRequestRef"); + f.field("transport_id", &self.transport_id()); + f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CreateWebRtcServerRequest { + impl<'a> ::core::convert::TryFrom> + for CreatePipeTransportRequest + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreateWebRtcServerRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CreatePipeTransportRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - web_rtc_server_id: ::core::convert::TryInto::try_into( - value.web_rtc_server_id()?, - )?, - listen_infos: if let ::core::option::Option::Some(listen_infos) = - value.listen_infos()? - { - ::core::option::Option::Some(listen_infos.to_vec_result()?) - } else { - ::core::option::Option::None - }, + transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + options: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.options()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for CreateWebRtcServerRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreatePipeTransportRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -58985,7 +60997,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateWebRtcServerRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreatePipeTransportRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -58995,7 +61007,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateWebRtcServerRequestRef]", + "[CreatePipeTransportRequestRef]", "get", buffer.offset_from_start, ) @@ -59003,10 +61015,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreateWebRtcServerRequest + impl ::planus::VectorWrite<::planus::Offset> + for CreatePipeTransportRequest { - type Value = ::planus::Offset; + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -59015,7 +61027,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -59030,7 +61042,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateWebRtcServerRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreatePipeTransportRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -59041,7 +61053,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreateWebRtcServerRequestRef]", + "[CreatePipeTransportRequestRef]", "read_as_root", 0, ) @@ -59049,10 +61061,10 @@ mod root { } } - /// The table `CloseWebRtcServerRequest` in the namespace `FBS.Worker` + /// The table `CreatePlainTransportRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CloseWebRtcServerRequest` in the file `../worker/fbs/worker.fbs:46` + /// * Table `CreatePlainTransportRequest` in the file `../worker/fbs/router.fbs:28` #[derive( Clone, Debug, @@ -59064,52 +61076,63 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CloseWebRtcServerRequest { - /// The field `web_rtc_server_id` in the table `CloseWebRtcServerRequest` - pub web_rtc_server_id: ::planus::alloc::string::String, + pub struct CreatePlainTransportRequest { + /// The field `transport_id` in the table `CreatePlainTransportRequest` + pub transport_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreatePlainTransportRequest` + pub options: + ::planus::alloc::boxed::Box, } - impl CloseWebRtcServerRequest { - /// Creates a [CloseWebRtcServerRequestBuilder] for serializing an instance of this table. + impl CreatePlainTransportRequest { + /// Creates a [CreatePlainTransportRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CloseWebRtcServerRequestBuilder<()> { - CloseWebRtcServerRequestBuilder(()) + pub fn builder() -> CreatePlainTransportRequestBuilder<()> { + CreatePlainTransportRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, + field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_options: impl ::planus::WriteAs< + ::planus::Offset, + >, ) -> ::planus::Offset { - let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); + let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_options = field_options.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); + object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CloseWebRtcServerRequest { + impl ::planus::WriteAs<::planus::Offset> + for CreatePlainTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CloseWebRtcServerRequest + impl ::planus::WriteAsOptional<::planus::Offset> + for CreatePlainTransportRequest { type Prepared = ::planus::Offset; @@ -59117,138 +61140,180 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CloseWebRtcServerRequest { + impl ::planus::WriteAsOffset for CreatePlainTransportRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CloseWebRtcServerRequest::create(builder, &self.web_rtc_server_id) + ) -> ::planus::Offset { + CreatePlainTransportRequest::create(builder, &self.transport_id, &self.options) } } - /// Builder for serializing an instance of the [CloseWebRtcServerRequest] type. + /// Builder for serializing an instance of the [CreatePlainTransportRequest] type. /// - /// Can be created using the [CloseWebRtcServerRequest::builder] method. + /// Can be created using the [CreatePlainTransportRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CloseWebRtcServerRequestBuilder(State); + pub struct CreatePlainTransportRequestBuilder(State); - impl CloseWebRtcServerRequestBuilder<()> { - /// Setter for the [`web_rtc_server_id` field](CloseWebRtcServerRequest#structfield.web_rtc_server_id). + impl CreatePlainTransportRequestBuilder<()> { + /// Setter for the [`transport_id` field](CreatePlainTransportRequest#structfield.transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_server_id( + pub fn transport_id( self, value: T0, - ) -> CloseWebRtcServerRequestBuilder<(T0,)> + ) -> CreatePlainTransportRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CloseWebRtcServerRequestBuilder((value,)) + CreatePlainTransportRequestBuilder((value,)) } } - impl CloseWebRtcServerRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseWebRtcServerRequest]. + impl CreatePlainTransportRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreatePlainTransportRequest#structfield.options). + #[inline] + #[allow(clippy::type_complexity)] + pub fn options(self, value: T1) -> CreatePlainTransportRequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAs< + ::planus::Offset, + >, + { + let (v0,) = self.0; + CreatePlainTransportRequestBuilder((v0, value)) + } + } + + impl CreatePlainTransportRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreatePlainTransportRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for CloseWebRtcServerRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for CreatePlainTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for CloseWebRtcServerRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > + ::planus::WriteAsOptional<::planus::Offset> + for CreatePlainTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset - for CloseWebRtcServerRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for CreatePlainTransportRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - CloseWebRtcServerRequest::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + CreatePlainTransportRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [CloseWebRtcServerRequest]. + /// Reference to a deserialized [CreatePlainTransportRequest]. #[derive(Copy, Clone)] - pub struct CloseWebRtcServerRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreatePlainTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CloseWebRtcServerRequestRef<'a> { - /// Getter for the [`web_rtc_server_id` field](CloseWebRtcServerRequest#structfield.web_rtc_server_id). + impl<'a> CreatePlainTransportRequestRef<'a> { + /// Getter for the [`transport_id` field](CreatePlainTransportRequest#structfield.transport_id). #[inline] - pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(0, "CloseWebRtcServerRequest", "web_rtc_server_id") + .access_required(0, "CreatePlainTransportRequest", "transport_id") + } + + /// Getter for the [`options` field](CreatePlainTransportRequest#structfield.options). + #[inline] + pub fn options( + &self, + ) -> ::planus::Result> + { + self.0 + .access_required(1, "CreatePlainTransportRequest", "options") } } - impl<'a> ::core::fmt::Debug for CloseWebRtcServerRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CreatePlainTransportRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CloseWebRtcServerRequestRef"); - f.field("web_rtc_server_id", &self.web_rtc_server_id()); + let mut f = f.debug_struct("CreatePlainTransportRequestRef"); + f.field("transport_id", &self.transport_id()); + f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CloseWebRtcServerRequest { + impl<'a> ::core::convert::TryFrom> + for CreatePlainTransportRequest + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CloseWebRtcServerRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CreatePlainTransportRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - web_rtc_server_id: ::core::convert::TryInto::try_into( - value.web_rtc_server_id()?, - )?, + transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + options: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.options()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for CloseWebRtcServerRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreatePlainTransportRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -59260,7 +61325,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CloseWebRtcServerRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreatePlainTransportRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -59270,7 +61335,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CloseWebRtcServerRequestRef]", + "[CreatePlainTransportRequestRef]", "get", buffer.offset_from_start, ) @@ -59278,10 +61343,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CloseWebRtcServerRequest + impl ::planus::VectorWrite<::planus::Offset> + for CreatePlainTransportRequest { - type Value = ::planus::Offset; + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -59290,7 +61355,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -59305,7 +61370,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CloseWebRtcServerRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreatePlainTransportRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -59316,7 +61381,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CloseWebRtcServerRequestRef]", + "[CreatePlainTransportRequestRef]", "read_as_root", 0, ) @@ -59324,10 +61389,10 @@ mod root { } } - /// The table `CreateRouterRequest` in the namespace `FBS.Worker` + /// The table `CreateWebRtcTransportRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CreateRouterRequest` in the file `../worker/fbs/worker.fbs:50` + /// * Table `CreateWebRtcTransportRequest` in the file `../worker/fbs/router.fbs:33` #[derive( Clone, Debug, @@ -59339,181 +61404,244 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateRouterRequest { - /// The field `router_id` in the table `CreateRouterRequest` - pub router_id: ::planus::alloc::string::String, + pub struct CreateWebRtcTransportRequest { + /// The field `transport_id` in the table `CreateWebRtcTransportRequest` + pub transport_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreateWebRtcTransportRequest` + pub options: + ::planus::alloc::boxed::Box, } - impl CreateRouterRequest { - /// Creates a [CreateRouterRequestBuilder] for serializing an instance of this table. + impl CreateWebRtcTransportRequest { + /// Creates a [CreateWebRtcTransportRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateRouterRequestBuilder<()> { - CreateRouterRequestBuilder(()) + pub fn builder() -> CreateWebRtcTransportRequestBuilder<()> { + CreateWebRtcTransportRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_router_id: impl ::planus::WriteAs<::planus::Offset>, + field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_options: impl ::planus::WriteAs< + ::planus::Offset, + >, ) -> ::planus::Offset { - let prepared_router_id = field_router_id.prepare(builder); + let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_options = field_options.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_router_id); + object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CreateRouterRequest { + impl ::planus::WriteAs<::planus::Offset> + for CreateWebRtcTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for CreateRouterRequest { + impl ::planus::WriteAsOptional<::planus::Offset> + for CreateWebRtcTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreateRouterRequest { + impl ::planus::WriteAsOffset for CreateWebRtcTransportRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateRouterRequest::create(builder, &self.router_id) + ) -> ::planus::Offset { + CreateWebRtcTransportRequest::create(builder, &self.transport_id, &self.options) } } - /// Builder for serializing an instance of the [CreateRouterRequest] type. + /// Builder for serializing an instance of the [CreateWebRtcTransportRequest] type. /// - /// Can be created using the [CreateRouterRequest::builder] method. + /// Can be created using the [CreateWebRtcTransportRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateRouterRequestBuilder(State); + pub struct CreateWebRtcTransportRequestBuilder(State); - impl CreateRouterRequestBuilder<()> { - /// Setter for the [`router_id` field](CreateRouterRequest#structfield.router_id). + impl CreateWebRtcTransportRequestBuilder<()> { + /// Setter for the [`transport_id` field](CreateWebRtcTransportRequest#structfield.transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn router_id(self, value: T0) -> CreateRouterRequestBuilder<(T0,)> + pub fn transport_id( + self, + value: T0, + ) -> CreateWebRtcTransportRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreateRouterRequestBuilder((value,)) + CreateWebRtcTransportRequestBuilder((value,)) } } - impl CreateRouterRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateRouterRequest]. + impl CreateWebRtcTransportRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreateWebRtcTransportRequest#structfield.options). + #[inline] + #[allow(clippy::type_complexity)] + pub fn options(self, value: T1) -> CreateWebRtcTransportRequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAs< + ::planus::Offset, + >, + { + let (v0,) = self.0; + CreateWebRtcTransportRequestBuilder((v0, value)) + } + } + + impl CreateWebRtcTransportRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateWebRtcTransportRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for CreateRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for CreateWebRtcTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for CreateRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > + ::planus::WriteAsOptional<::planus::Offset> + for CreateWebRtcTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset for CreateRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for CreateWebRtcTransportRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - CreateRouterRequest::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + CreateWebRtcTransportRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [CreateRouterRequest]. + /// Reference to a deserialized [CreateWebRtcTransportRequest]. #[derive(Copy, Clone)] - pub struct CreateRouterRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreateWebRtcTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreateRouterRequestRef<'a> { - /// Getter for the [`router_id` field](CreateRouterRequest#structfield.router_id). + impl<'a> CreateWebRtcTransportRequestRef<'a> { + /// Getter for the [`transport_id` field](CreateWebRtcTransportRequest#structfield.transport_id). #[inline] - pub fn router_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(0, "CreateRouterRequest", "router_id") + .access_required(0, "CreateWebRtcTransportRequest", "transport_id") + } + + /// Getter for the [`options` field](CreateWebRtcTransportRequest#structfield.options). + #[inline] + pub fn options( + &self, + ) -> ::planus::Result> + { + self.0 + .access_required(1, "CreateWebRtcTransportRequest", "options") } } - impl<'a> ::core::fmt::Debug for CreateRouterRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CreateWebRtcTransportRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateRouterRequestRef"); - f.field("router_id", &self.router_id()); + let mut f = f.debug_struct("CreateWebRtcTransportRequestRef"); + f.field("transport_id", &self.transport_id()); + f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CreateRouterRequest { + impl<'a> ::core::convert::TryFrom> + for CreateWebRtcTransportRequest + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreateRouterRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CreateWebRtcTransportRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - router_id: ::core::convert::TryInto::try_into(value.router_id()?)?, + transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + options: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.options()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for CreateRouterRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreateWebRtcTransportRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -59525,7 +61653,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateRouterRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreateWebRtcTransportRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -59535,7 +61663,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateRouterRequestRef]", + "[CreateWebRtcTransportRequestRef]", "get", buffer.offset_from_start, ) @@ -59543,8 +61671,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for CreateRouterRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> + for CreateWebRtcTransportRequest + { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -59553,7 +61683,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -59568,7 +61698,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateRouterRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreateWebRtcTransportRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -59579,7 +61709,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreateRouterRequestRef]", + "[CreateWebRtcTransportRequestRef]", "read_as_root", 0, ) @@ -59587,10 +61717,10 @@ mod root { } } - /// The table `CloseRouterRequest` in the namespace `FBS.Worker` + /// The table `CreateDirectTransportRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CloseRouterRequest` in the file `../worker/fbs/worker.fbs:54` + /// * Table `CreateDirectTransportRequest` in the file `../worker/fbs/router.fbs:38` #[derive( Clone, Debug, @@ -59602,180 +61732,244 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CloseRouterRequest { - /// The field `router_id` in the table `CloseRouterRequest` - pub router_id: ::planus::alloc::string::String, + pub struct CreateDirectTransportRequest { + /// The field `transport_id` in the table `CreateDirectTransportRequest` + pub transport_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreateDirectTransportRequest` + pub options: + ::planus::alloc::boxed::Box, } - impl CloseRouterRequest { - /// Creates a [CloseRouterRequestBuilder] for serializing an instance of this table. + impl CreateDirectTransportRequest { + /// Creates a [CreateDirectTransportRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CloseRouterRequestBuilder<()> { - CloseRouterRequestBuilder(()) + pub fn builder() -> CreateDirectTransportRequestBuilder<()> { + CreateDirectTransportRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_router_id: impl ::planus::WriteAs<::planus::Offset>, + field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_options: impl ::planus::WriteAs< + ::planus::Offset, + >, ) -> ::planus::Offset { - let prepared_router_id = field_router_id.prepare(builder); + let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_options = field_options.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_router_id); + object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CloseRouterRequest { + impl ::planus::WriteAs<::planus::Offset> + for CreateDirectTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for CloseRouterRequest { + impl ::planus::WriteAsOptional<::planus::Offset> + for CreateDirectTransportRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CloseRouterRequest { + impl ::planus::WriteAsOffset for CreateDirectTransportRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CloseRouterRequest::create(builder, &self.router_id) + ) -> ::planus::Offset { + CreateDirectTransportRequest::create(builder, &self.transport_id, &self.options) } } - /// Builder for serializing an instance of the [CloseRouterRequest] type. + /// Builder for serializing an instance of the [CreateDirectTransportRequest] type. /// - /// Can be created using the [CloseRouterRequest::builder] method. + /// Can be created using the [CreateDirectTransportRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CloseRouterRequestBuilder(State); + pub struct CreateDirectTransportRequestBuilder(State); - impl CloseRouterRequestBuilder<()> { - /// Setter for the [`router_id` field](CloseRouterRequest#structfield.router_id). + impl CreateDirectTransportRequestBuilder<()> { + /// Setter for the [`transport_id` field](CreateDirectTransportRequest#structfield.transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn router_id(self, value: T0) -> CloseRouterRequestBuilder<(T0,)> + pub fn transport_id( + self, + value: T0, + ) -> CreateDirectTransportRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CloseRouterRequestBuilder((value,)) + CreateDirectTransportRequestBuilder((value,)) } } - impl CloseRouterRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseRouterRequest]. + impl CreateDirectTransportRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreateDirectTransportRequest#structfield.options). + #[inline] + #[allow(clippy::type_complexity)] + pub fn options(self, value: T1) -> CreateDirectTransportRequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAs< + ::planus::Offset, + >, + { + let (v0,) = self.0; + CreateDirectTransportRequestBuilder((v0, value)) + } + } + + impl CreateDirectTransportRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateDirectTransportRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for CloseRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for CreateDirectTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for CloseRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > + ::planus::WriteAsOptional<::planus::Offset> + for CreateDirectTransportRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset for CloseRouterRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for CreateDirectTransportRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - CloseRouterRequest::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + CreateDirectTransportRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [CloseRouterRequest]. + /// Reference to a deserialized [CreateDirectTransportRequest]. #[derive(Copy, Clone)] - pub struct CloseRouterRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreateDirectTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CloseRouterRequestRef<'a> { - /// Getter for the [`router_id` field](CloseRouterRequest#structfield.router_id). + impl<'a> CreateDirectTransportRequestRef<'a> { + /// Getter for the [`transport_id` field](CreateDirectTransportRequest#structfield.transport_id). #[inline] - pub fn router_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "CloseRouterRequest", "router_id") + pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "CreateDirectTransportRequest", "transport_id") + } + + /// Getter for the [`options` field](CreateDirectTransportRequest#structfield.options). + #[inline] + pub fn options( + &self, + ) -> ::planus::Result> + { + self.0 + .access_required(1, "CreateDirectTransportRequest", "options") } } - impl<'a> ::core::fmt::Debug for CloseRouterRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CreateDirectTransportRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CloseRouterRequestRef"); - f.field("router_id", &self.router_id()); + let mut f = f.debug_struct("CreateDirectTransportRequestRef"); + f.field("transport_id", &self.transport_id()); + f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CloseRouterRequest { + impl<'a> ::core::convert::TryFrom> + for CreateDirectTransportRequest + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CloseRouterRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CreateDirectTransportRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - router_id: ::core::convert::TryInto::try_into(value.router_id()?)?, + transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + options: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.options()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for CloseRouterRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreateDirectTransportRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -59787,7 +61981,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CloseRouterRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreateDirectTransportRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -59797,7 +61991,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CloseRouterRequestRef]", + "[CreateDirectTransportRequestRef]", "get", buffer.offset_from_start, ) @@ -59805,8 +61999,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for CloseRouterRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> + for CreateDirectTransportRequest + { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -59815,7 +62011,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -59830,7 +62026,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CloseRouterRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreateDirectTransportRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -59840,20 +62036,19 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[CloseRouterRequestRef]", "read_as_root", 0) + error_kind.with_error_location( + "[CreateDirectTransportRequestRef]", + "read_as_root", + 0, + ) }) } } - } - /// The namespace `FBS.Router` - /// - /// Generated from these locations: - /// * File `../worker/fbs/router.fbs` - pub mod router { - /// The table `DumpResponse` in the namespace `FBS.Router` + + /// The table `CreateAudioLevelObserverRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/router.fbs:12` + /// * Table `CreateAudioLevelObserverRequest` in the file `../worker/fbs/router.fbs:43` #[derive( Clone, Debug, @@ -59865,300 +62060,142 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct DumpResponse { - /// The field `id` in the table `DumpResponse` - pub id: ::planus::alloc::string::String, - /// The field `transport_ids` in the table `DumpResponse` - pub transport_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `rtp_observer_ids` in the table `DumpResponse` - pub rtp_observer_ids: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `map_producer_id_consumer_ids` in the table `DumpResponse` - pub map_producer_id_consumer_ids: - ::planus::alloc::vec::Vec, - /// The field `map_consumer_id_producer_id` in the table `DumpResponse` - pub map_consumer_id_producer_id: - ::planus::alloc::vec::Vec, - /// The field `map_producer_id_observer_ids` in the table `DumpResponse` - pub map_producer_id_observer_ids: - ::planus::alloc::vec::Vec, - /// The field `map_data_producer_id_data_consumer_ids` in the table `DumpResponse` - pub map_data_producer_id_data_consumer_ids: - ::planus::alloc::vec::Vec, - /// The field `map_data_consumer_id_data_producer_id` in the table `DumpResponse` - pub map_data_consumer_id_data_producer_id: - ::planus::alloc::vec::Vec, + pub struct CreateAudioLevelObserverRequest { + /// The field `rtp_observer_id` in the table `CreateAudioLevelObserverRequest` + pub rtp_observer_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreateAudioLevelObserverRequest` + pub options: ::planus::alloc::boxed::Box< + super::audio_level_observer::AudioLevelObserverOptions, + >, } - impl DumpResponse { - /// Creates a [DumpResponseBuilder] for serializing an instance of this table. + impl CreateAudioLevelObserverRequest { + /// Creates a [CreateAudioLevelObserverRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> DumpResponseBuilder<()> { - DumpResponseBuilder(()) + pub fn builder() -> CreateAudioLevelObserverRequestBuilder<()> { + CreateAudioLevelObserverRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_id: impl ::planus::WriteAs<::planus::Offset>, - field_transport_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_rtp_observer_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_map_producer_id_consumer_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_map_consumer_id_producer_id: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_map_producer_id_observer_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_map_data_producer_id_data_consumer_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_map_data_consumer_id_data_producer_id: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + field_rtp_observer_id: impl ::planus::WriteAs<::planus::Offset>, + field_options: impl ::planus::WriteAs< + ::planus::Offset, >, ) -> ::planus::Offset { - let prepared_id = field_id.prepare(builder); - let prepared_transport_ids = field_transport_ids.prepare(builder); - let prepared_rtp_observer_ids = field_rtp_observer_ids.prepare(builder); - let prepared_map_producer_id_consumer_ids = - field_map_producer_id_consumer_ids.prepare(builder); - let prepared_map_consumer_id_producer_id = - field_map_consumer_id_producer_id.prepare(builder); - let prepared_map_producer_id_observer_ids = - field_map_producer_id_observer_ids.prepare(builder); - let prepared_map_data_producer_id_data_consumer_ids = - field_map_data_producer_id_data_consumer_ids.prepare(builder); - let prepared_map_data_consumer_id_data_producer_id = - field_map_data_consumer_id_data_producer_id.prepare(builder); + let prepared_rtp_observer_id = field_rtp_observer_id.prepare(builder); + let prepared_options = field_options.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<20> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(1); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(2); - table_writer.write_entry::<::planus::Offset< - [::planus::Offset], - >>(3); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(4); - table_writer.write_entry::<::planus::Offset< - [::planus::Offset], - >>(5); table_writer.write_entry::<::planus::Offset< - [::planus::Offset], - >>(6); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(7); + super::audio_level_observer::AudioLevelObserverOptions, + >>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_id); - object_writer.write::<_, _, 4>(&prepared_transport_ids); - object_writer.write::<_, _, 4>(&prepared_rtp_observer_ids); - object_writer.write::<_, _, 4>(&prepared_map_producer_id_consumer_ids); - object_writer.write::<_, _, 4>(&prepared_map_consumer_id_producer_id); - object_writer.write::<_, _, 4>(&prepared_map_producer_id_observer_ids); - object_writer - .write::<_, _, 4>(&prepared_map_data_producer_id_data_consumer_ids); - object_writer - .write::<_, _, 4>(&prepared_map_data_consumer_id_data_producer_id); + object_writer.write::<_, _, 4>(&prepared_rtp_observer_id); + object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + impl ::planus::WriteAs<::planus::Offset> + for CreateAudioLevelObserverRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + impl ::planus::WriteAsOptional<::planus::Offset> + for CreateAudioLevelObserverRequest + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for DumpResponse { + impl ::planus::WriteAsOffset for CreateAudioLevelObserverRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DumpResponse::create( + ) -> ::planus::Offset { + CreateAudioLevelObserverRequest::create( builder, - &self.id, - &self.transport_ids, - &self.rtp_observer_ids, - &self.map_producer_id_consumer_ids, - &self.map_consumer_id_producer_id, - &self.map_producer_id_observer_ids, - &self.map_data_producer_id_data_consumer_ids, - &self.map_data_consumer_id_data_producer_id, + &self.rtp_observer_id, + &self.options, ) } } - /// Builder for serializing an instance of the [DumpResponse] type. + /// Builder for serializing an instance of the [CreateAudioLevelObserverRequest] type. /// - /// Can be created using the [DumpResponse::builder] method. + /// Can be created using the [CreateAudioLevelObserverRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct DumpResponseBuilder(State); - - impl DumpResponseBuilder<()> { - /// Setter for the [`id` field](DumpResponse#structfield.id). - #[inline] - #[allow(clippy::type_complexity)] - pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - DumpResponseBuilder((value,)) - } - } - - impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`transport_ids` field](DumpResponse#structfield.transport_ids). - #[inline] - #[allow(clippy::type_complexity)] - pub fn transport_ids(self, value: T1) -> DumpResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0,) = self.0; - DumpResponseBuilder((v0, value)) - } - } - - impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`rtp_observer_ids` field](DumpResponse#structfield.rtp_observer_ids). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtp_observer_ids(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0, v1) = self.0; - DumpResponseBuilder((v0, v1, value)) - } - } - - impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`map_producer_id_consumer_ids` field](DumpResponse#structfield.map_producer_id_consumer_ids). - #[inline] - #[allow(clippy::type_complexity)] - pub fn map_producer_id_consumer_ids( - self, - value: T3, - ) -> DumpResponseBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - { - let (v0, v1, v2) = self.0; - DumpResponseBuilder((v0, v1, v2, value)) - } - } - - impl DumpResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`map_consumer_id_producer_id` field](DumpResponse#structfield.map_consumer_id_producer_id). - #[inline] - #[allow(clippy::type_complexity)] - pub fn map_consumer_id_producer_id( - self, - value: T4, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> - where - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - { - let (v0, v1, v2, v3) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, value)) - } - } - - impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`map_producer_id_observer_ids` field](DumpResponse#structfield.map_producer_id_observer_ids). - #[inline] - #[allow(clippy::type_complexity)] - pub fn map_producer_id_observer_ids( - self, - value: T5, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> - where - T5: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - { - let (v0, v1, v2, v3, v4) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, value)) - } - } + pub struct CreateAudioLevelObserverRequestBuilder(State); - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Setter for the [`map_data_producer_id_data_consumer_ids` field](DumpResponse#structfield.map_data_producer_id_data_consumer_ids). + impl CreateAudioLevelObserverRequestBuilder<()> { + /// Setter for the [`rtp_observer_id` field](CreateAudioLevelObserverRequest#structfield.rtp_observer_id). #[inline] #[allow(clippy::type_complexity)] - pub fn map_data_producer_id_data_consumer_ids( + pub fn rtp_observer_id( self, - value: T6, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> + value: T0, + ) -> CreateAudioLevelObserverRequestBuilder<(T0,)> where - T6: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, + T0: ::planus::WriteAs<::planus::Offset>, { - let (v0, v1, v2, v3, v4, v5) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, v5, value)) + CreateAudioLevelObserverRequestBuilder((value,)) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - /// Setter for the [`map_data_consumer_id_data_producer_id` field](DumpResponse#structfield.map_data_consumer_id_data_producer_id). + impl CreateAudioLevelObserverRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreateAudioLevelObserverRequest#structfield.options). #[inline] #[allow(clippy::type_complexity)] - pub fn map_data_consumer_id_data_producer_id( + pub fn options( self, - value: T7, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + value: T1, + ) -> CreateAudioLevelObserverRequestBuilder<(T0, T1)> where - T7: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, { - let (v0, v1, v2, v3, v4, v5, v6) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + let (v0,) = self.0; + CreateAudioLevelObserverRequestBuilder((v0, value)) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + impl CreateAudioLevelObserverRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateAudioLevelObserverRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -60166,255 +62203,115 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T7: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + > ::planus::WriteAs<::planus::Offset> + for CreateAudioLevelObserverRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T7: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + > + ::planus::WriteAsOptional<::planus::Offset> + for CreateAudioLevelObserverRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T7: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T1: ::planus::WriteAs< + ::planus::Offset, >, - > ::planus::WriteAsOffset - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + > ::planus::WriteAsOffset + for CreateAudioLevelObserverRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5, v6, v7) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3, v4, v5, v6, v7) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + CreateAudioLevelObserverRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [DumpResponse]. + /// Reference to a deserialized [CreateAudioLevelObserverRequest]. #[derive(Copy, Clone)] - pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> DumpResponseRef<'a> { - /// Getter for the [`id` field](DumpResponse#structfield.id). - #[inline] - pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "DumpResponse", "id") - } - - /// Getter for the [`transport_ids` field](DumpResponse#structfield.transport_ids). - #[inline] - pub fn transport_ids( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0.access_required(1, "DumpResponse", "transport_ids") - } - - /// Getter for the [`rtp_observer_ids` field](DumpResponse#structfield.rtp_observer_ids). - #[inline] - pub fn rtp_observer_ids( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0 - .access_required(2, "DumpResponse", "rtp_observer_ids") - } - - /// Getter for the [`map_producer_id_consumer_ids` field](DumpResponse#structfield.map_producer_id_consumer_ids). - #[inline] - pub fn map_producer_id_consumer_ids( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0 - .access_required(3, "DumpResponse", "map_producer_id_consumer_ids") - } + pub struct CreateAudioLevelObserverRequestRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`map_consumer_id_producer_id` field](DumpResponse#structfield.map_consumer_id_producer_id). + impl<'a> CreateAudioLevelObserverRequestRef<'a> { + /// Getter for the [`rtp_observer_id` field](CreateAudioLevelObserverRequest#structfield.rtp_observer_id). #[inline] - pub fn map_consumer_id_producer_id( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { + pub fn rtp_observer_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(4, "DumpResponse", "map_consumer_id_producer_id") + .access_required(0, "CreateAudioLevelObserverRequest", "rtp_observer_id") } - /// Getter for the [`map_producer_id_observer_ids` field](DumpResponse#structfield.map_producer_id_observer_ids). + /// Getter for the [`options` field](CreateAudioLevelObserverRequest#structfield.options). #[inline] - pub fn map_producer_id_observer_ids( + pub fn options( &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { + ) -> ::planus::Result> + { self.0 - .access_required(5, "DumpResponse", "map_producer_id_observer_ids") - } - - /// Getter for the [`map_data_producer_id_data_consumer_ids` field](DumpResponse#structfield.map_data_producer_id_data_consumer_ids). - #[inline] - pub fn map_data_producer_id_data_consumer_ids( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0.access_required( - 6, - "DumpResponse", - "map_data_producer_id_data_consumer_ids", - ) - } - - /// Getter for the [`map_data_consumer_id_data_producer_id` field](DumpResponse#structfield.map_data_consumer_id_data_producer_id). - #[inline] - pub fn map_data_consumer_id_data_producer_id( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0.access_required( - 7, - "DumpResponse", - "map_data_consumer_id_data_producer_id", - ) + .access_required(1, "CreateAudioLevelObserverRequest", "options") } } - impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + impl<'a> ::core::fmt::Debug for CreateAudioLevelObserverRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DumpResponseRef"); - f.field("id", &self.id()); - f.field("transport_ids", &self.transport_ids()); - f.field("rtp_observer_ids", &self.rtp_observer_ids()); - f.field( - "map_producer_id_consumer_ids", - &self.map_producer_id_consumer_ids(), - ); - f.field( - "map_consumer_id_producer_id", - &self.map_consumer_id_producer_id(), - ); - f.field( - "map_producer_id_observer_ids", - &self.map_producer_id_observer_ids(), - ); - f.field( - "map_data_producer_id_data_consumer_ids", - &self.map_data_producer_id_data_consumer_ids(), - ); - f.field( - "map_data_consumer_id_data_producer_id", - &self.map_data_consumer_id_data_producer_id(), - ); + let mut f = f.debug_struct("CreateAudioLevelObserverRequestRef"); + f.field("rtp_observer_id", &self.rtp_observer_id()); + f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for DumpResponse { + impl<'a> ::core::convert::TryFrom> + for CreateAudioLevelObserverRequest + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { + fn try_from( + value: CreateAudioLevelObserverRequestRef<'a>, + ) -> ::planus::Result { ::core::result::Result::Ok(Self { - id: ::core::convert::TryInto::try_into(value.id()?)?, - transport_ids: value.transport_ids()?.to_vec_result()?, - rtp_observer_ids: value.rtp_observer_ids()?.to_vec_result()?, - map_producer_id_consumer_ids: value - .map_producer_id_consumer_ids()? - .to_vec_result()?, - map_consumer_id_producer_id: value - .map_consumer_id_producer_id()? - .to_vec_result()?, - map_producer_id_observer_ids: value - .map_producer_id_observer_ids()? - .to_vec_result()?, - map_data_producer_id_data_consumer_ids: value - .map_data_producer_id_data_consumer_ids()? - .to_vec_result()?, - map_data_consumer_id_data_producer_id: value - .map_data_consumer_id_data_producer_id()? - .to_vec_result()?, + rtp_observer_id: ::core::convert::TryInto::try_into( + value.rtp_observer_id()?, + )?, + options: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.options()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreateAudioLevelObserverRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -60426,7 +62323,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreateAudioLevelObserverRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -60436,7 +62333,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[DumpResponseRef]", + "[CreateAudioLevelObserverRequestRef]", "get", buffer.offset_from_start, ) @@ -60444,8 +62341,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> + for CreateAudioLevelObserverRequest + { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -60454,7 +62353,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -60469,7 +62368,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreateAudioLevelObserverRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -60479,15 +62378,19 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + error_kind.with_error_location( + "[CreateAudioLevelObserverRequestRef]", + "read_as_root", + 0, + ) }) } } - /// The table `CreatePipeTransportRequest` in the namespace `FBS.Router` + /// The table `CreateActiveSpeakerObserverRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CreatePipeTransportRequest` in the file `../worker/fbs/router.fbs:23` + /// * Table `CreateActiveSpeakerObserverRequest` in the file `../worker/fbs/router.fbs:48` #[derive( Clone, Debug, @@ -60499,40 +62402,46 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreatePipeTransportRequest { - /// The field `transport_id` in the table `CreatePipeTransportRequest` - pub transport_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreatePipeTransportRequest` - pub options: - ::planus::alloc::boxed::Box, + pub struct CreateActiveSpeakerObserverRequest { + /// The field `active_speaker_observer_id` in the table `CreateActiveSpeakerObserverRequest` + pub active_speaker_observer_id: ::planus::alloc::string::String, + /// The field `options` in the table `CreateActiveSpeakerObserverRequest` + pub options: ::planus::alloc::boxed::Box< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, } - impl CreatePipeTransportRequest { - /// Creates a [CreatePipeTransportRequestBuilder] for serializing an instance of this table. + impl CreateActiveSpeakerObserverRequest { + /// Creates a [CreateActiveSpeakerObserverRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreatePipeTransportRequestBuilder<()> { - CreatePipeTransportRequestBuilder(()) + pub fn builder() -> CreateActiveSpeakerObserverRequestBuilder<()> { + CreateActiveSpeakerObserverRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_active_speaker_observer_id: impl ::planus::WriteAs<::planus::Offset>, field_options: impl ::planus::WriteAs< - ::planus::Offset, + ::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, >, ) -> ::planus::Offset { - let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_active_speaker_observer_id = + field_active_speaker_observer_id.prepare(builder); let prepared_options = field_options.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); + table_writer.write_entry::<::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_active_speaker_observer_id); object_writer.write::<_, _, 4>(&prepared_options); }); } @@ -60540,8 +62449,8 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> - for CreatePipeTransportRequest + impl ::planus::WriteAs<::planus::Offset> + for CreateActiveSpeakerObserverRequest { type Prepared = ::planus::Offset; @@ -60549,13 +62458,13 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreatePipeTransportRequest + impl ::planus::WriteAsOptional<::planus::Offset> + for CreateActiveSpeakerObserverRequest { type Prepared = ::planus::Offset; @@ -60563,65 +62472,79 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreatePipeTransportRequest { + impl ::planus::WriteAsOffset + for CreateActiveSpeakerObserverRequest + { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreatePipeTransportRequest::create(builder, &self.transport_id, &self.options) + ) -> ::planus::Offset { + CreateActiveSpeakerObserverRequest::create( + builder, + &self.active_speaker_observer_id, + &self.options, + ) } } - /// Builder for serializing an instance of the [CreatePipeTransportRequest] type. + /// Builder for serializing an instance of the [CreateActiveSpeakerObserverRequest] type. /// - /// Can be created using the [CreatePipeTransportRequest::builder] method. + /// Can be created using the [CreateActiveSpeakerObserverRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CreatePipeTransportRequestBuilder(State); + pub struct CreateActiveSpeakerObserverRequestBuilder(State); - impl CreatePipeTransportRequestBuilder<()> { - /// Setter for the [`transport_id` field](CreatePipeTransportRequest#structfield.transport_id). + impl CreateActiveSpeakerObserverRequestBuilder<()> { + /// Setter for the [`active_speaker_observer_id` field](CreateActiveSpeakerObserverRequest#structfield.active_speaker_observer_id). #[inline] #[allow(clippy::type_complexity)] - pub fn transport_id(self, value: T0) -> CreatePipeTransportRequestBuilder<(T0,)> + pub fn active_speaker_observer_id( + self, + value: T0, + ) -> CreateActiveSpeakerObserverRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreatePipeTransportRequestBuilder((value,)) + CreateActiveSpeakerObserverRequestBuilder((value,)) } } - impl CreatePipeTransportRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreatePipeTransportRequest#structfield.options). + impl CreateActiveSpeakerObserverRequestBuilder<(T0,)> { + /// Setter for the [`options` field](CreateActiveSpeakerObserverRequest#structfield.options). #[inline] #[allow(clippy::type_complexity)] - pub fn options(self, value: T1) -> CreatePipeTransportRequestBuilder<(T0, T1)> + pub fn options( + self, + value: T1, + ) -> CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> where T1: ::planus::WriteAs< - ::planus::Offset, + ::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, >, { let (v0,) = self.0; - CreatePipeTransportRequestBuilder((v0, value)) + CreateActiveSpeakerObserverRequestBuilder((v0, value)) } } - impl CreatePipeTransportRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreatePipeTransportRequest]. + impl CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateActiveSpeakerObserverRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -60630,18 +62553,21 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs< - ::planus::Offset, + ::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, >, - > ::planus::WriteAs<::planus::Offset> - for CreatePipeTransportRequestBuilder<(T0, T1)> + > + ::planus::WriteAs<::planus::Offset> + for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } @@ -60649,19 +62575,21 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs< - ::planus::Offset, + ::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, >, > - ::planus::WriteAsOptional<::planus::Offset> - for CreatePipeTransportRequestBuilder<(T0, T1)> + ::planus::WriteAsOptional<::planus::Offset> + for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } @@ -60670,62 +62598,77 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs< - ::planus::Offset, + ::planus::Offset< + super::active_speaker_observer::ActiveSpeakerObserverOptions, + >, >, - > ::planus::WriteAsOffset - for CreatePipeTransportRequestBuilder<(T0, T1)> + > ::planus::WriteAsOffset + for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0, v1) = &self.0; - CreatePipeTransportRequest::create(builder, v0, v1) + CreateActiveSpeakerObserverRequest::create(builder, v0, v1) } } - /// Reference to a deserialized [CreatePipeTransportRequest]. + /// Reference to a deserialized [CreateActiveSpeakerObserverRequest]. #[derive(Copy, Clone)] - pub struct CreatePipeTransportRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CreateActiveSpeakerObserverRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreatePipeTransportRequestRef<'a> { - /// Getter for the [`transport_id` field](CreatePipeTransportRequest#structfield.transport_id). + impl<'a> CreateActiveSpeakerObserverRequestRef<'a> { + /// Getter for the [`active_speaker_observer_id` field](CreateActiveSpeakerObserverRequest#structfield.active_speaker_observer_id). #[inline] - pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "CreatePipeTransportRequest", "transport_id") + pub fn active_speaker_observer_id( + &self, + ) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required( + 0, + "CreateActiveSpeakerObserverRequest", + "active_speaker_observer_id", + ) } - /// Getter for the [`options` field](CreatePipeTransportRequest#structfield.options). + /// Getter for the [`options` field](CreateActiveSpeakerObserverRequest#structfield.options). #[inline] pub fn options( &self, - ) -> ::planus::Result> - { + ) -> ::planus::Result< + super::active_speaker_observer::ActiveSpeakerObserverOptionsRef<'a>, + > { self.0 - .access_required(1, "CreatePipeTransportRequest", "options") + .access_required(1, "CreateActiveSpeakerObserverRequest", "options") } } - impl<'a> ::core::fmt::Debug for CreatePipeTransportRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CreateActiveSpeakerObserverRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreatePipeTransportRequestRef"); - f.field("transport_id", &self.transport_id()); + let mut f = f.debug_struct("CreateActiveSpeakerObserverRequestRef"); + f.field( + "active_speaker_observer_id", + &self.active_speaker_observer_id(), + ); f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreatePipeTransportRequest + impl<'a> ::core::convert::TryFrom> + for CreateActiveSpeakerObserverRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreatePipeTransportRequestRef<'a>) -> ::planus::Result { + fn try_from( + value: CreateActiveSpeakerObserverRequestRef<'a>, + ) -> ::planus::Result { ::core::result::Result::Ok(Self { - transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + active_speaker_observer_id: ::core::convert::TryInto::try_into( + value.active_speaker_observer_id()?, + )?, options: ::planus::alloc::boxed::Box::new( ::core::convert::TryInto::try_into(value.options()?)?, ), @@ -60733,7 +62676,7 @@ mod root { } } - impl<'a> ::planus::TableRead<'a> for CreatePipeTransportRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CreateActiveSpeakerObserverRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -60745,7 +62688,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreatePipeTransportRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CreateActiveSpeakerObserverRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -60755,7 +62698,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreatePipeTransportRequestRef]", + "[CreateActiveSpeakerObserverRequestRef]", "get", buffer.offset_from_start, ) @@ -60763,10 +62706,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreatePipeTransportRequest + impl ::planus::VectorWrite<::planus::Offset> + for CreateActiveSpeakerObserverRequest { - type Value = ::planus::Offset; + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -60775,7 +62718,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -60790,7 +62733,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreatePipeTransportRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CreateActiveSpeakerObserverRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -60801,7 +62744,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreatePipeTransportRequestRef]", + "[CreateActiveSpeakerObserverRequestRef]", "read_as_root", 0, ) @@ -60809,10 +62752,10 @@ mod root { } } - /// The table `CreatePlainTransportRequest` in the namespace `FBS.Router` + /// The table `CloseTransportRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CreatePlainTransportRequest` in the file `../worker/fbs/router.fbs:28` + /// * Table `CloseTransportRequest` in the file `../worker/fbs/router.fbs:53` #[derive( Clone, Debug, @@ -60824,244 +62767,184 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreatePlainTransportRequest { - /// The field `transport_id` in the table `CreatePlainTransportRequest` + pub struct CloseTransportRequest { + /// The field `transport_id` in the table `CloseTransportRequest` pub transport_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreatePlainTransportRequest` - pub options: - ::planus::alloc::boxed::Box, } - impl CreatePlainTransportRequest { - /// Creates a [CreatePlainTransportRequestBuilder] for serializing an instance of this table. + impl CloseTransportRequest { + /// Creates a [CloseTransportRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreatePlainTransportRequestBuilder<()> { - CreatePlainTransportRequestBuilder(()) + pub fn builder() -> CloseTransportRequestBuilder<()> { + CloseTransportRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, field_transport_id: impl ::planus::WriteAs<::planus::Offset>, - field_options: impl ::planus::WriteAs< - ::planus::Offset, - >, ) -> ::planus::Offset { let prepared_transport_id = field_transport_id.prepare(builder); - let prepared_options = field_options.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_transport_id); - object_writer.write::<_, _, 4>(&prepared_options); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> - for CreatePlainTransportRequest - { + impl ::planus::WriteAs<::planus::Offset> for CloseTransportRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreatePlainTransportRequest - { + impl ::planus::WriteAsOptional<::planus::Offset> for CloseTransportRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreatePlainTransportRequest { + impl ::planus::WriteAsOffset for CloseTransportRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreatePlainTransportRequest::create(builder, &self.transport_id, &self.options) + ) -> ::planus::Offset { + CloseTransportRequest::create(builder, &self.transport_id) } } - /// Builder for serializing an instance of the [CreatePlainTransportRequest] type. + /// Builder for serializing an instance of the [CloseTransportRequest] type. /// - /// Can be created using the [CreatePlainTransportRequest::builder] method. + /// Can be created using the [CloseTransportRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CreatePlainTransportRequestBuilder(State); + pub struct CloseTransportRequestBuilder(State); - impl CreatePlainTransportRequestBuilder<()> { - /// Setter for the [`transport_id` field](CreatePlainTransportRequest#structfield.transport_id). + impl CloseTransportRequestBuilder<()> { + /// Setter for the [`transport_id` field](CloseTransportRequest#structfield.transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn transport_id( - self, - value: T0, - ) -> CreatePlainTransportRequestBuilder<(T0,)> + pub fn transport_id(self, value: T0) -> CloseTransportRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreatePlainTransportRequestBuilder((value,)) - } - } - - impl CreatePlainTransportRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreatePlainTransportRequest#structfield.options). - #[inline] - #[allow(clippy::type_complexity)] - pub fn options(self, value: T1) -> CreatePlainTransportRequestBuilder<(T0, T1)> - where - T1: ::planus::WriteAs< - ::planus::Offset, - >, - { - let (v0,) = self.0; - CreatePlainTransportRequestBuilder((v0, value)) + CloseTransportRequestBuilder((value,)) } } - impl CreatePlainTransportRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreatePlainTransportRequest]. + impl CloseTransportRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseTransportRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAs<::planus::Offset> - for CreatePlainTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAs<::planus::Offset> + for CloseTransportRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > - ::planus::WriteAsOptional<::planus::Offset> - for CreatePlainTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for CloseTransportRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAsOffset - for CreatePlainTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOffset + for CloseTransportRequestBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - CreatePlainTransportRequest::create(builder, v0, v1) + ) -> ::planus::Offset { + let (v0,) = &self.0; + CloseTransportRequest::create(builder, v0) } } - /// Reference to a deserialized [CreatePlainTransportRequest]. + /// Reference to a deserialized [CloseTransportRequest]. #[derive(Copy, Clone)] - pub struct CreatePlainTransportRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct CloseTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreatePlainTransportRequestRef<'a> { - /// Getter for the [`transport_id` field](CreatePlainTransportRequest#structfield.transport_id). + impl<'a> CloseTransportRequestRef<'a> { + /// Getter for the [`transport_id` field](CloseTransportRequest#structfield.transport_id). #[inline] pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(0, "CreatePlainTransportRequest", "transport_id") - } - - /// Getter for the [`options` field](CreatePlainTransportRequest#structfield.options). - #[inline] - pub fn options( - &self, - ) -> ::planus::Result> - { - self.0 - .access_required(1, "CreatePlainTransportRequest", "options") + .access_required(0, "CloseTransportRequest", "transport_id") } } - impl<'a> ::core::fmt::Debug for CreatePlainTransportRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CloseTransportRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreatePlainTransportRequestRef"); + let mut f = f.debug_struct("CloseTransportRequestRef"); f.field("transport_id", &self.transport_id()); - f.field("options", &self.options()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreatePlainTransportRequest - { + impl<'a> ::core::convert::TryFrom> for CloseTransportRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreatePlainTransportRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CloseTransportRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, - options: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.options()?)?, - ), }) } } - impl<'a> ::planus::TableRead<'a> for CreatePlainTransportRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CloseTransportRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -61073,7 +62956,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreatePlainTransportRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CloseTransportRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -61083,7 +62966,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreatePlainTransportRequestRef]", + "[CloseTransportRequestRef]", "get", buffer.offset_from_start, ) @@ -61091,10 +62974,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreatePlainTransportRequest - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for CloseTransportRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -61103,7 +62984,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -61118,7 +62999,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreatePlainTransportRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CloseTransportRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -61129,7 +63010,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreatePlainTransportRequestRef]", + "[CloseTransportRequestRef]", "read_as_root", 0, ) @@ -61137,10 +63018,10 @@ mod root { } } - /// The table `CreateWebRtcTransportRequest` in the namespace `FBS.Router` + /// The table `CloseRtpObserverRequest` in the namespace `FBS.Router` /// /// Generated from these locations: - /// * Table `CreateWebRtcTransportRequest` in the file `../worker/fbs/router.fbs:33` + /// * Table `CloseRtpObserverRequest` in the file `../worker/fbs/router.fbs:57` #[derive( Clone, Debug, @@ -61152,63 +63033,52 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateWebRtcTransportRequest { - /// The field `transport_id` in the table `CreateWebRtcTransportRequest` - pub transport_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreateWebRtcTransportRequest` - pub options: - ::planus::alloc::boxed::Box, + pub struct CloseRtpObserverRequest { + /// The field `rtp_observer_id` in the table `CloseRtpObserverRequest` + pub rtp_observer_id: ::planus::alloc::string::String, } - impl CreateWebRtcTransportRequest { - /// Creates a [CreateWebRtcTransportRequestBuilder] for serializing an instance of this table. + impl CloseRtpObserverRequest { + /// Creates a [CloseRtpObserverRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateWebRtcTransportRequestBuilder<()> { - CreateWebRtcTransportRequestBuilder(()) + pub fn builder() -> CloseRtpObserverRequestBuilder<()> { + CloseRtpObserverRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_transport_id: impl ::planus::WriteAs<::planus::Offset>, - field_options: impl ::planus::WriteAs< - ::planus::Offset, - >, + field_rtp_observer_id: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_transport_id = field_transport_id.prepare(builder); - let prepared_options = field_options.prepare(builder); + let prepared_rtp_observer_id = field_rtp_observer_id.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_transport_id); - object_writer.write::<_, _, 4>(&prepared_options); + object_writer.write::<_, _, 4>(&prepared_rtp_observer_id); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> - for CreateWebRtcTransportRequest - { + impl ::planus::WriteAs<::planus::Offset> for CloseRtpObserverRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreateWebRtcTransportRequest + impl ::planus::WriteAsOptional<::planus::Offset> + for CloseRtpObserverRequest { type Prepared = ::planus::Offset; @@ -61216,180 +63086,135 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreateWebRtcTransportRequest { + impl ::planus::WriteAsOffset for CloseRtpObserverRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateWebRtcTransportRequest::create(builder, &self.transport_id, &self.options) + ) -> ::planus::Offset { + CloseRtpObserverRequest::create(builder, &self.rtp_observer_id) } } - /// Builder for serializing an instance of the [CreateWebRtcTransportRequest] type. + /// Builder for serializing an instance of the [CloseRtpObserverRequest] type. /// - /// Can be created using the [CreateWebRtcTransportRequest::builder] method. + /// Can be created using the [CloseRtpObserverRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateWebRtcTransportRequestBuilder(State); + pub struct CloseRtpObserverRequestBuilder(State); - impl CreateWebRtcTransportRequestBuilder<()> { - /// Setter for the [`transport_id` field](CreateWebRtcTransportRequest#structfield.transport_id). + impl CloseRtpObserverRequestBuilder<()> { + /// Setter for the [`rtp_observer_id` field](CloseRtpObserverRequest#structfield.rtp_observer_id). #[inline] #[allow(clippy::type_complexity)] - pub fn transport_id( - self, - value: T0, - ) -> CreateWebRtcTransportRequestBuilder<(T0,)> + pub fn rtp_observer_id(self, value: T0) -> CloseRtpObserverRequestBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreateWebRtcTransportRequestBuilder((value,)) - } - } - - impl CreateWebRtcTransportRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreateWebRtcTransportRequest#structfield.options). - #[inline] - #[allow(clippy::type_complexity)] - pub fn options(self, value: T1) -> CreateWebRtcTransportRequestBuilder<(T0, T1)> - where - T1: ::planus::WriteAs< - ::planus::Offset, - >, - { - let (v0,) = self.0; - CreateWebRtcTransportRequestBuilder((v0, value)) + CloseRtpObserverRequestBuilder((value,)) } } - impl CreateWebRtcTransportRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateWebRtcTransportRequest]. + impl CloseRtpObserverRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseRtpObserverRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAs<::planus::Offset> - for CreateWebRtcTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAs<::planus::Offset> + for CloseRtpObserverRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > - ::planus::WriteAsOptional<::planus::Offset> - for CreateWebRtcTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for CloseRtpObserverRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAsOffset - for CreateWebRtcTransportRequestBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOffset + for CloseRtpObserverRequestBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - CreateWebRtcTransportRequest::create(builder, v0, v1) + ) -> ::planus::Offset { + let (v0,) = &self.0; + CloseRtpObserverRequest::create(builder, v0) } } - /// Reference to a deserialized [CreateWebRtcTransportRequest]. + /// Reference to a deserialized [CloseRtpObserverRequest]. #[derive(Copy, Clone)] - pub struct CreateWebRtcTransportRequestRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> CreateWebRtcTransportRequestRef<'a> { - /// Getter for the [`transport_id` field](CreateWebRtcTransportRequest#structfield.transport_id). - #[inline] - pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "CreateWebRtcTransportRequest", "transport_id") - } + pub struct CloseRtpObserverRequestRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`options` field](CreateWebRtcTransportRequest#structfield.options). + impl<'a> CloseRtpObserverRequestRef<'a> { + /// Getter for the [`rtp_observer_id` field](CloseRtpObserverRequest#structfield.rtp_observer_id). #[inline] - pub fn options( - &self, - ) -> ::planus::Result> - { + pub fn rtp_observer_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(1, "CreateWebRtcTransportRequest", "options") + .access_required(0, "CloseRtpObserverRequest", "rtp_observer_id") } } - impl<'a> ::core::fmt::Debug for CreateWebRtcTransportRequestRef<'a> { + impl<'a> ::core::fmt::Debug for CloseRtpObserverRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateWebRtcTransportRequestRef"); - f.field("transport_id", &self.transport_id()); - f.field("options", &self.options()); + let mut f = f.debug_struct("CloseRtpObserverRequestRef"); + f.field("rtp_observer_id", &self.rtp_observer_id()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreateWebRtcTransportRequest - { + impl<'a> ::core::convert::TryFrom> for CloseRtpObserverRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreateWebRtcTransportRequestRef<'a>) -> ::planus::Result { + fn try_from(value: CloseRtpObserverRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, - options: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.options()?)?, - ), + rtp_observer_id: ::core::convert::TryInto::try_into( + value.rtp_observer_id()?, + )?, }) } } - impl<'a> ::planus::TableRead<'a> for CreateWebRtcTransportRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for CloseRtpObserverRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -61401,7 +63226,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateWebRtcTransportRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for CloseRtpObserverRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -61411,7 +63236,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateWebRtcTransportRequestRef]", + "[CloseRtpObserverRequestRef]", "get", buffer.offset_from_start, ) @@ -61419,10 +63244,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreateWebRtcTransportRequest - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for CloseRtpObserverRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -61431,7 +63254,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -61446,7 +63269,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateWebRtcTransportRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for CloseRtpObserverRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -61457,18 +63280,23 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreateWebRtcTransportRequestRef]", + "[CloseRtpObserverRequestRef]", "read_as_root", 0, ) }) } } - - /// The table `CreateDirectTransportRequest` in the namespace `FBS.Router` + } + /// The namespace `FBS.WebRtcServer` + /// + /// Generated from these locations: + /// * File `../worker/fbs/webRtcServer.fbs` + pub mod web_rtc_server { + /// The table `IpPort` in the namespace `FBS.WebRtcServer` /// /// Generated from these locations: - /// * Table `CreateDirectTransportRequest` in the file `../worker/fbs/router.fbs:38` + /// * Table `IpPort` in the file `../worker/fbs/webRtcServer.fbs:5` #[derive( Clone, Debug, @@ -61480,132 +63308,121 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateDirectTransportRequest { - /// The field `transport_id` in the table `CreateDirectTransportRequest` - pub transport_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreateDirectTransportRequest` - pub options: - ::planus::alloc::boxed::Box, + pub struct IpPort { + /// The field `ip` in the table `IpPort` + pub ip: ::planus::alloc::string::String, + /// The field `port` in the table `IpPort` + pub port: u16, } - impl CreateDirectTransportRequest { - /// Creates a [CreateDirectTransportRequestBuilder] for serializing an instance of this table. + impl IpPort { + /// Creates a [IpPortBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateDirectTransportRequestBuilder<()> { - CreateDirectTransportRequestBuilder(()) + pub fn builder() -> IpPortBuilder<()> { + IpPortBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_transport_id: impl ::planus::WriteAs<::planus::Offset>, - field_options: impl ::planus::WriteAs< - ::planus::Offset, - >, + field_ip: impl ::planus::WriteAs<::planus::Offset>, + field_port: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_transport_id = field_transport_id.prepare(builder); - let prepared_options = field_options.prepare(builder); + let prepared_ip = field_ip.prepare(builder); + let prepared_port = field_port.prepare(builder, &0); let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); + if prepared_port.is_some() { + table_writer.write_entry::(1); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_transport_id); - object_writer.write::<_, _, 4>(&prepared_options); + object_writer.write::<_, _, 4>(&prepared_ip); + if let ::core::option::Option::Some(prepared_port) = prepared_port { + object_writer.write::<_, _, 2>(&prepared_port); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> - for CreateDirectTransportRequest - { + impl ::planus::WriteAs<::planus::Offset> for IpPort { type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreateDirectTransportRequest - { + impl ::planus::WriteAsOptional<::planus::Offset> for IpPort { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreateDirectTransportRequest { + impl ::planus::WriteAsOffset for IpPort { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateDirectTransportRequest::create(builder, &self.transport_id, &self.options) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + IpPort::create(builder, &self.ip, self.port) } } - /// Builder for serializing an instance of the [CreateDirectTransportRequest] type. + /// Builder for serializing an instance of the [IpPort] type. /// - /// Can be created using the [CreateDirectTransportRequest::builder] method. + /// Can be created using the [IpPort::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateDirectTransportRequestBuilder(State); + pub struct IpPortBuilder(State); - impl CreateDirectTransportRequestBuilder<()> { - /// Setter for the [`transport_id` field](CreateDirectTransportRequest#structfield.transport_id). + impl IpPortBuilder<()> { + /// Setter for the [`ip` field](IpPort#structfield.ip). #[inline] #[allow(clippy::type_complexity)] - pub fn transport_id( - self, - value: T0, - ) -> CreateDirectTransportRequestBuilder<(T0,)> + pub fn ip(self, value: T0) -> IpPortBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreateDirectTransportRequestBuilder((value,)) + IpPortBuilder((value,)) } } - impl CreateDirectTransportRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreateDirectTransportRequest#structfield.options). + impl IpPortBuilder<(T0,)> { + /// Setter for the [`port` field](IpPort#structfield.port). #[inline] #[allow(clippy::type_complexity)] - pub fn options(self, value: T1) -> CreateDirectTransportRequestBuilder<(T0, T1)> + pub fn port(self, value: T1) -> IpPortBuilder<(T0, T1)> where - T1: ::planus::WriteAs< - ::planus::Offset, - >, + T1: ::planus::WriteAsDefault, { let (v0,) = self.0; - CreateDirectTransportRequestBuilder((v0, value)) + IpPortBuilder((v0, value)) + } + + /// Sets the [`port` field](IpPort#structfield.port) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn port_as_default(self) -> IpPortBuilder<(T0, ::planus::DefaultValue)> { + self.port(::planus::DefaultValue) } } - impl CreateDirectTransportRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateDirectTransportRequest]. + impl IpPortBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IpPort]. #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -61613,111 +63430,85 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAs<::planus::Offset> - for CreateDirectTransportRequestBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> for IpPortBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > - ::planus::WriteAsOptional<::planus::Offset> - for CreateDirectTransportRequestBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> for IpPortBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAsOffset - for CreateDirectTransportRequestBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset for IpPortBuilder<(T0, T1)> { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { let (v0, v1) = &self.0; - CreateDirectTransportRequest::create(builder, v0, v1) + IpPort::create(builder, v0, v1) } } - /// Reference to a deserialized [CreateDirectTransportRequest]. + /// Reference to a deserialized [IpPort]. #[derive(Copy, Clone)] - pub struct CreateDirectTransportRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct IpPortRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreateDirectTransportRequestRef<'a> { - /// Getter for the [`transport_id` field](CreateDirectTransportRequest#structfield.transport_id). + impl<'a> IpPortRef<'a> { + /// Getter for the [`ip` field](IpPort#structfield.ip). #[inline] - pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "CreateDirectTransportRequest", "transport_id") + pub fn ip(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "IpPort", "ip") } - /// Getter for the [`options` field](CreateDirectTransportRequest#structfield.options). + /// Getter for the [`port` field](IpPort#structfield.port). #[inline] - pub fn options( - &self, - ) -> ::planus::Result> - { - self.0 - .access_required(1, "CreateDirectTransportRequest", "options") + pub fn port(&self) -> ::planus::Result { + ::core::result::Result::Ok(self.0.access(1, "IpPort", "port")?.unwrap_or(0)) } } - impl<'a> ::core::fmt::Debug for CreateDirectTransportRequestRef<'a> { + impl<'a> ::core::fmt::Debug for IpPortRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateDirectTransportRequestRef"); - f.field("transport_id", &self.transport_id()); - f.field("options", &self.options()); + let mut f = f.debug_struct("IpPortRef"); + f.field("ip", &self.ip()); + f.field("port", &self.port()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreateDirectTransportRequest - { + impl<'a> ::core::convert::TryFrom> for IpPort { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CreateDirectTransportRequestRef<'a>) -> ::planus::Result { + fn try_from(value: IpPortRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, - options: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.options()?)?, - ), + ip: ::core::convert::TryInto::try_into(value.ip()?)?, + port: ::core::convert::TryInto::try_into(value.port()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for CreateDirectTransportRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for IpPortRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -61729,7 +63520,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateDirectTransportRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for IpPortRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -61739,7 +63530,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateDirectTransportRequestRef]", + "[IpPortRef]", "get", buffer.offset_from_start, ) @@ -61747,10 +63538,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreateDirectTransportRequest - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for IpPort { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -61759,7 +63548,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -61774,7 +63563,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateDirectTransportRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for IpPortRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -61784,19 +63573,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[CreateDirectTransportRequestRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[IpPortRef]", "read_as_root", 0) }) } } - /// The table `CreateAudioLevelObserverRequest` in the namespace `FBS.Router` + /// The table `IceUserNameFragment` in the namespace `FBS.WebRtcServer` /// /// Generated from these locations: - /// * Table `CreateAudioLevelObserverRequest` in the file `../worker/fbs/router.fbs:43` + /// * Table `IceUserNameFragment` in the file `../worker/fbs/webRtcServer.fbs:10` #[derive( Clone, Debug, @@ -61808,142 +63593,130 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateAudioLevelObserverRequest { - /// The field `rtp_observer_id` in the table `CreateAudioLevelObserverRequest` - pub rtp_observer_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreateAudioLevelObserverRequest` - pub options: ::planus::alloc::boxed::Box< - super::audio_level_observer::AudioLevelObserverOptions, - >, + pub struct IceUserNameFragment { + /// The field `local_ice_username_fragment` in the table `IceUserNameFragment` + pub local_ice_username_fragment: ::planus::alloc::string::String, + /// The field `web_rtc_transport_id` in the table `IceUserNameFragment` + pub web_rtc_transport_id: ::planus::alloc::string::String, } - impl CreateAudioLevelObserverRequest { - /// Creates a [CreateAudioLevelObserverRequestBuilder] for serializing an instance of this table. + impl IceUserNameFragment { + /// Creates a [IceUserNameFragmentBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateAudioLevelObserverRequestBuilder<()> { - CreateAudioLevelObserverRequestBuilder(()) + pub fn builder() -> IceUserNameFragmentBuilder<()> { + IceUserNameFragmentBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_rtp_observer_id: impl ::planus::WriteAs<::planus::Offset>, - field_options: impl ::planus::WriteAs< - ::planus::Offset, - >, + field_local_ice_username_fragment: impl ::planus::WriteAs<::planus::Offset>, + field_web_rtc_transport_id: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_rtp_observer_id = field_rtp_observer_id.prepare(builder); - let prepared_options = field_options.prepare(builder); + let prepared_local_ice_username_fragment = + field_local_ice_username_fragment.prepare(builder); + let prepared_web_rtc_transport_id = field_web_rtc_transport_id.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset< - super::audio_level_observer::AudioLevelObserverOptions, - >>(1); + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_rtp_observer_id); - object_writer.write::<_, _, 4>(&prepared_options); + object_writer.write::<_, _, 4>(&prepared_local_ice_username_fragment); + object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_id); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> - for CreateAudioLevelObserverRequest - { + impl ::planus::WriteAs<::planus::Offset> for IceUserNameFragment { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreateAudioLevelObserverRequest - { + impl ::planus::WriteAsOptional<::planus::Offset> for IceUserNameFragment { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CreateAudioLevelObserverRequest { + impl ::planus::WriteAsOffset for IceUserNameFragment { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateAudioLevelObserverRequest::create( + ) -> ::planus::Offset { + IceUserNameFragment::create( builder, - &self.rtp_observer_id, - &self.options, + &self.local_ice_username_fragment, + &self.web_rtc_transport_id, ) } } - /// Builder for serializing an instance of the [CreateAudioLevelObserverRequest] type. + /// Builder for serializing an instance of the [IceUserNameFragment] type. /// - /// Can be created using the [CreateAudioLevelObserverRequest::builder] method. + /// Can be created using the [IceUserNameFragment::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateAudioLevelObserverRequestBuilder(State); + pub struct IceUserNameFragmentBuilder(State); - impl CreateAudioLevelObserverRequestBuilder<()> { - /// Setter for the [`rtp_observer_id` field](CreateAudioLevelObserverRequest#structfield.rtp_observer_id). + impl IceUserNameFragmentBuilder<()> { + /// Setter for the [`local_ice_username_fragment` field](IceUserNameFragment#structfield.local_ice_username_fragment). #[inline] #[allow(clippy::type_complexity)] - pub fn rtp_observer_id( + pub fn local_ice_username_fragment( self, value: T0, - ) -> CreateAudioLevelObserverRequestBuilder<(T0,)> + ) -> IceUserNameFragmentBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CreateAudioLevelObserverRequestBuilder((value,)) + IceUserNameFragmentBuilder((value,)) } } - impl CreateAudioLevelObserverRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreateAudioLevelObserverRequest#structfield.options). + impl IceUserNameFragmentBuilder<(T0,)> { + /// Setter for the [`web_rtc_transport_id` field](IceUserNameFragment#structfield.web_rtc_transport_id). #[inline] #[allow(clippy::type_complexity)] - pub fn options( + pub fn web_rtc_transport_id( self, value: T1, - ) -> CreateAudioLevelObserverRequestBuilder<(T0, T1)> + ) -> IceUserNameFragmentBuilder<(T0, T1)> where - T1: ::planus::WriteAs< - ::planus::Offset, - >, + T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - CreateAudioLevelObserverRequestBuilder((v0, value)) + IceUserNameFragmentBuilder((v0, value)) } } - impl CreateAudioLevelObserverRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateAudioLevelObserverRequest]. + impl IceUserNameFragmentBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IceUserNameFragment]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -61951,115 +63724,105 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAs<::planus::Offset> - for CreateAudioLevelObserverRequestBuilder<(T0, T1)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> + for IceUserNameFragmentBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > - ::planus::WriteAsOptional<::planus::Offset> - for CreateAudioLevelObserverRequestBuilder<(T0, T1)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for IceUserNameFragmentBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset, - >, - > ::planus::WriteAsOffset - for CreateAudioLevelObserverRequestBuilder<(T0, T1)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset + for IceUserNameFragmentBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0, v1) = &self.0; - CreateAudioLevelObserverRequest::create(builder, v0, v1) + IceUserNameFragment::create(builder, v0, v1) } } - /// Reference to a deserialized [CreateAudioLevelObserverRequest]. + /// Reference to a deserialized [IceUserNameFragment]. #[derive(Copy, Clone)] - pub struct CreateAudioLevelObserverRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct IceUserNameFragmentRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreateAudioLevelObserverRequestRef<'a> { - /// Getter for the [`rtp_observer_id` field](CreateAudioLevelObserverRequest#structfield.rtp_observer_id). + impl<'a> IceUserNameFragmentRef<'a> { + /// Getter for the [`local_ice_username_fragment` field](IceUserNameFragment#structfield.local_ice_username_fragment). #[inline] - pub fn rtp_observer_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn local_ice_username_fragment( + &self, + ) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(0, "CreateAudioLevelObserverRequest", "rtp_observer_id") + .access_required(0, "IceUserNameFragment", "local_ice_username_fragment") } - /// Getter for the [`options` field](CreateAudioLevelObserverRequest#structfield.options). + /// Getter for the [`web_rtc_transport_id` field](IceUserNameFragment#structfield.web_rtc_transport_id). #[inline] - pub fn options( - &self, - ) -> ::planus::Result> - { + pub fn web_rtc_transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(1, "CreateAudioLevelObserverRequest", "options") + .access_required(1, "IceUserNameFragment", "web_rtc_transport_id") } } - impl<'a> ::core::fmt::Debug for CreateAudioLevelObserverRequestRef<'a> { + impl<'a> ::core::fmt::Debug for IceUserNameFragmentRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateAudioLevelObserverRequestRef"); - f.field("rtp_observer_id", &self.rtp_observer_id()); - f.field("options", &self.options()); + let mut f = f.debug_struct("IceUserNameFragmentRef"); + f.field( + "local_ice_username_fragment", + &self.local_ice_username_fragment(), + ); + f.field("web_rtc_transport_id", &self.web_rtc_transport_id()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreateAudioLevelObserverRequest - { + impl<'a> ::core::convert::TryFrom> for IceUserNameFragment { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from( - value: CreateAudioLevelObserverRequestRef<'a>, - ) -> ::planus::Result { + fn try_from(value: IceUserNameFragmentRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - rtp_observer_id: ::core::convert::TryInto::try_into( - value.rtp_observer_id()?, + local_ice_username_fragment: ::core::convert::TryInto::try_into( + value.local_ice_username_fragment()?, + )?, + web_rtc_transport_id: ::core::convert::TryInto::try_into( + value.web_rtc_transport_id()?, )?, - options: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.options()?)?, - ), }) } } - impl<'a> ::planus::TableRead<'a> for CreateAudioLevelObserverRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for IceUserNameFragmentRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -62071,7 +63834,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateAudioLevelObserverRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for IceUserNameFragmentRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -62081,7 +63844,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateAudioLevelObserverRequestRef]", + "[IceUserNameFragmentRef]", "get", buffer.offset_from_start, ) @@ -62089,10 +63852,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreateAudioLevelObserverRequest - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for IceUserNameFragment { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -62101,7 +63862,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -62116,7 +63877,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateAudioLevelObserverRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for IceUserNameFragmentRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -62127,7 +63888,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CreateAudioLevelObserverRequestRef]", + "[IceUserNameFragmentRef]", "read_as_root", 0, ) @@ -62135,10 +63896,10 @@ mod root { } } - /// The table `CreateActiveSpeakerObserverRequest` in the namespace `FBS.Router` + /// The table `TupleHash` in the namespace `FBS.WebRtcServer` /// /// Generated from these locations: - /// * Table `CreateActiveSpeakerObserverRequest` in the file `../worker/fbs/router.fbs:48` + /// * Table `TupleHash` in the file `../worker/fbs/webRtcServer.fbs:15` #[derive( Clone, Debug, @@ -62150,281 +63911,231 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CreateActiveSpeakerObserverRequest { - /// The field `active_speaker_observer_id` in the table `CreateActiveSpeakerObserverRequest` - pub active_speaker_observer_id: ::planus::alloc::string::String, - /// The field `options` in the table `CreateActiveSpeakerObserverRequest` - pub options: ::planus::alloc::boxed::Box< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, + pub struct TupleHash { + /// The field `local_ice_username_fragment` in the table `TupleHash` + pub local_ice_username_fragment: u64, + /// The field `web_rtc_transport_id` in the table `TupleHash` + pub web_rtc_transport_id: ::planus::alloc::string::String, } - impl CreateActiveSpeakerObserverRequest { - /// Creates a [CreateActiveSpeakerObserverRequestBuilder] for serializing an instance of this table. + impl TupleHash { + /// Creates a [TupleHashBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CreateActiveSpeakerObserverRequestBuilder<()> { - CreateActiveSpeakerObserverRequestBuilder(()) + pub fn builder() -> TupleHashBuilder<()> { + TupleHashBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_active_speaker_observer_id: impl ::planus::WriteAs<::planus::Offset>, - field_options: impl ::planus::WriteAs< - ::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, - >, + field_local_ice_username_fragment: impl ::planus::WriteAsDefault, + field_web_rtc_transport_id: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_active_speaker_observer_id = - field_active_speaker_observer_id.prepare(builder); - let prepared_options = field_options.prepare(builder); + let prepared_local_ice_username_fragment = + field_local_ice_username_fragment.prepare(builder, &0); + let prepared_web_rtc_transport_id = field_web_rtc_transport_id.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >>(1); + if prepared_local_ice_username_fragment.is_some() { + table_writer.write_entry::(0); + } + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_active_speaker_observer_id); - object_writer.write::<_, _, 4>(&prepared_options); + if let ::core::option::Option::Some( + prepared_local_ice_username_fragment, + ) = prepared_local_ice_username_fragment + { + object_writer + .write::<_, _, 8>(&prepared_local_ice_username_fragment); + } + object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_id); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> - for CreateActiveSpeakerObserverRequest - { + impl ::planus::WriteAs<::planus::Offset> for TupleHash { type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CreateActiveSpeakerObserverRequest - { + impl ::planus::WriteAsOptional<::planus::Offset> for TupleHash { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset - for CreateActiveSpeakerObserverRequest - { + impl ::planus::WriteAsOffset for TupleHash { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CreateActiveSpeakerObserverRequest::create( + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + TupleHash::create( builder, - &self.active_speaker_observer_id, - &self.options, + self.local_ice_username_fragment, + &self.web_rtc_transport_id, ) } } - /// Builder for serializing an instance of the [CreateActiveSpeakerObserverRequest] type. + /// Builder for serializing an instance of the [TupleHash] type. /// - /// Can be created using the [CreateActiveSpeakerObserverRequest::builder] method. + /// Can be created using the [TupleHash::builder] method. #[derive(Debug)] #[must_use] - pub struct CreateActiveSpeakerObserverRequestBuilder(State); + pub struct TupleHashBuilder(State); - impl CreateActiveSpeakerObserverRequestBuilder<()> { - /// Setter for the [`active_speaker_observer_id` field](CreateActiveSpeakerObserverRequest#structfield.active_speaker_observer_id). + impl TupleHashBuilder<()> { + /// Setter for the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment). #[inline] #[allow(clippy::type_complexity)] - pub fn active_speaker_observer_id( - self, - value: T0, - ) -> CreateActiveSpeakerObserverRequestBuilder<(T0,)> + pub fn local_ice_username_fragment(self, value: T0) -> TupleHashBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsDefault, { - CreateActiveSpeakerObserverRequestBuilder((value,)) + TupleHashBuilder((value,)) } - } - impl CreateActiveSpeakerObserverRequestBuilder<(T0,)> { - /// Setter for the [`options` field](CreateActiveSpeakerObserverRequest#structfield.options). + /// Sets the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn options( + pub fn local_ice_username_fragment_as_default( self, - value: T1, - ) -> CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> + ) -> TupleHashBuilder<(::planus::DefaultValue,)> { + self.local_ice_username_fragment(::planus::DefaultValue) + } + } + + impl TupleHashBuilder<(T0,)> { + /// Setter for the [`web_rtc_transport_id` field](TupleHash#structfield.web_rtc_transport_id). + #[inline] + #[allow(clippy::type_complexity)] + pub fn web_rtc_transport_id(self, value: T1) -> TupleHashBuilder<(T0, T1)> where - T1: ::planus::WriteAs< - ::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, - >, + T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - CreateActiveSpeakerObserverRequestBuilder((v0, value)) + TupleHashBuilder((v0, value)) } } - impl CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CreateActiveSpeakerObserverRequest]. + impl TupleHashBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TupleHash]. #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, - >, - > - ::planus::WriteAs<::planus::Offset> - for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> for TupleHashBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, - >, - > - ::planus::WriteAsOptional<::planus::Offset> - for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for TupleHashBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs< - ::planus::Offset< - super::active_speaker_observer::ActiveSpeakerObserverOptions, - >, - >, - > ::planus::WriteAsOffset - for CreateActiveSpeakerObserverRequestBuilder<(T0, T1)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset for TupleHashBuilder<(T0, T1)> { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { let (v0, v1) = &self.0; - CreateActiveSpeakerObserverRequest::create(builder, v0, v1) + TupleHash::create(builder, v0, v1) } } - /// Reference to a deserialized [CreateActiveSpeakerObserverRequest]. + /// Reference to a deserialized [TupleHash]. #[derive(Copy, Clone)] - pub struct CreateActiveSpeakerObserverRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct TupleHashRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CreateActiveSpeakerObserverRequestRef<'a> { - /// Getter for the [`active_speaker_observer_id` field](CreateActiveSpeakerObserverRequest#structfield.active_speaker_observer_id). + impl<'a> TupleHashRef<'a> { + /// Getter for the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment). #[inline] - pub fn active_speaker_observer_id( - &self, - ) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required( - 0, - "CreateActiveSpeakerObserverRequest", - "active_speaker_observer_id", + pub fn local_ice_username_fragment(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "TupleHash", "local_ice_username_fragment")? + .unwrap_or(0), ) } - /// Getter for the [`options` field](CreateActiveSpeakerObserverRequest#structfield.options). + /// Getter for the [`web_rtc_transport_id` field](TupleHash#structfield.web_rtc_transport_id). #[inline] - pub fn options( - &self, - ) -> ::planus::Result< - super::active_speaker_observer::ActiveSpeakerObserverOptionsRef<'a>, - > { + pub fn web_rtc_transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { self.0 - .access_required(1, "CreateActiveSpeakerObserverRequest", "options") + .access_required(1, "TupleHash", "web_rtc_transport_id") } } - impl<'a> ::core::fmt::Debug for CreateActiveSpeakerObserverRequestRef<'a> { + impl<'a> ::core::fmt::Debug for TupleHashRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CreateActiveSpeakerObserverRequestRef"); + let mut f = f.debug_struct("TupleHashRef"); f.field( - "active_speaker_observer_id", - &self.active_speaker_observer_id(), + "local_ice_username_fragment", + &self.local_ice_username_fragment(), ); - f.field("options", &self.options()); + f.field("web_rtc_transport_id", &self.web_rtc_transport_id()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for CreateActiveSpeakerObserverRequest - { + impl<'a> ::core::convert::TryFrom> for TupleHash { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from( - value: CreateActiveSpeakerObserverRequestRef<'a>, - ) -> ::planus::Result { + fn try_from(value: TupleHashRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - active_speaker_observer_id: ::core::convert::TryInto::try_into( - value.active_speaker_observer_id()?, + local_ice_username_fragment: ::core::convert::TryInto::try_into( + value.local_ice_username_fragment()?, + )?, + web_rtc_transport_id: ::core::convert::TryInto::try_into( + value.web_rtc_transport_id()?, )?, - options: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.options()?)?, - ), }) } } - impl<'a> ::planus::TableRead<'a> for CreateActiveSpeakerObserverRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for TupleHashRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -62436,7 +64147,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CreateActiveSpeakerObserverRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for TupleHashRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -62446,7 +64157,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CreateActiveSpeakerObserverRequestRef]", + "[TupleHashRef]", "get", buffer.offset_from_start, ) @@ -62454,10 +64165,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for CreateActiveSpeakerObserverRequest - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for TupleHash { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -62466,7 +64175,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -62481,7 +64190,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CreateActiveSpeakerObserverRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for TupleHashRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -62491,19 +64200,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[CreateActiveSpeakerObserverRequestRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[TupleHashRef]", "read_as_root", 0) }) } } - /// The table `CloseTransportRequest` in the namespace `FBS.Router` + /// The table `DumpResponse` in the namespace `FBS.WebRtcServer` /// /// Generated from these locations: - /// * Table `CloseTransportRequest` in the file `../worker/fbs/router.fbs:53` + /// * Table `DumpResponse` in the file `../worker/fbs/webRtcServer.fbs:20` #[derive( Clone, Debug, @@ -62515,184 +64220,400 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CloseTransportRequest { - /// The field `transport_id` in the table `CloseTransportRequest` - pub transport_id: ::planus::alloc::string::String, + pub struct DumpResponse { + /// The field `id` in the table `DumpResponse` + pub id: ::planus::alloc::string::String, + /// The field `udp_sockets` in the table `DumpResponse` + pub udp_sockets: ::planus::alloc::vec::Vec, + /// The field `tcp_servers` in the table `DumpResponse` + pub tcp_servers: ::planus::alloc::vec::Vec, + /// The field `web_rtc_transport_ids` in the table `DumpResponse` + pub web_rtc_transport_ids: + ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `local_ice_username_fragments` in the table `DumpResponse` + pub local_ice_username_fragments: + ::planus::alloc::vec::Vec, + /// The field `tuple_hashes` in the table `DumpResponse` + pub tuple_hashes: ::planus::alloc::vec::Vec, } - impl CloseTransportRequest { - /// Creates a [CloseTransportRequestBuilder] for serializing an instance of this table. + impl DumpResponse { + /// Creates a [DumpResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CloseTransportRequestBuilder<()> { - CloseTransportRequestBuilder(()) + pub fn builder() -> DumpResponseBuilder<()> { + DumpResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_id: impl ::planus::WriteAs<::planus::Offset>, + field_udp_sockets: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_tcp_servers: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_web_rtc_transport_ids: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_local_ice_username_fragments: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_tuple_hashes: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, ) -> ::planus::Offset { - let prepared_transport_id = field_transport_id.prepare(builder); + let prepared_id = field_id.prepare(builder); + let prepared_udp_sockets = field_udp_sockets.prepare(builder); + let prepared_tcp_servers = field_tcp_servers.prepare(builder); + let prepared_web_rtc_transport_ids = + field_web_rtc_transport_ids.prepare(builder); + let prepared_local_ice_username_fragments = + field_local_ice_username_fragments.prepare(builder); + let prepared_tuple_hashes = field_tuple_hashes.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<16> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); + table_writer + .write_entry::<::planus::Offset<[::planus::Offset]>>(1); + table_writer + .write_entry::<::planus::Offset<[::planus::Offset]>>(2); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(3); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(4); + table_writer + .write_entry::<::planus::Offset<[::planus::Offset]>>(5); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_transport_id); + object_writer.write::<_, _, 4>(&prepared_id); + object_writer.write::<_, _, 4>(&prepared_udp_sockets); + object_writer.write::<_, _, 4>(&prepared_tcp_servers); + object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_ids); + object_writer.write::<_, _, 4>(&prepared_local_ice_username_fragments); + object_writer.write::<_, _, 4>(&prepared_tuple_hashes); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CloseTransportRequest { + impl ::planus::WriteAs<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for CloseTransportRequest { + impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CloseTransportRequest { + impl ::planus::WriteAsOffset for DumpResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CloseTransportRequest::create(builder, &self.transport_id) + ) -> ::planus::Offset { + DumpResponse::create( + builder, + &self.id, + &self.udp_sockets, + &self.tcp_servers, + &self.web_rtc_transport_ids, + &self.local_ice_username_fragments, + &self.tuple_hashes, + ) } } - /// Builder for serializing an instance of the [CloseTransportRequest] type. + /// Builder for serializing an instance of the [DumpResponse] type. /// - /// Can be created using the [CloseTransportRequest::builder] method. + /// Can be created using the [DumpResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct CloseTransportRequestBuilder(State); + pub struct DumpResponseBuilder(State); - impl CloseTransportRequestBuilder<()> { - /// Setter for the [`transport_id` field](CloseTransportRequest#structfield.transport_id). + impl DumpResponseBuilder<()> { + /// Setter for the [`id` field](DumpResponse#structfield.id). #[inline] #[allow(clippy::type_complexity)] - pub fn transport_id(self, value: T0) -> CloseTransportRequestBuilder<(T0,)> + pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - CloseTransportRequestBuilder((value,)) + DumpResponseBuilder((value,)) } } - impl CloseTransportRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseTransportRequest]. + impl DumpResponseBuilder<(T0,)> { + /// Setter for the [`udp_sockets` field](DumpResponse#structfield.udp_sockets). + #[inline] + #[allow(clippy::type_complexity)] + pub fn udp_sockets(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0,) = self.0; + DumpResponseBuilder((v0, value)) + } + } + + impl DumpResponseBuilder<(T0, T1)> { + /// Setter for the [`tcp_servers` field](DumpResponse#structfield.tcp_servers). + #[inline] + #[allow(clippy::type_complexity)] + pub fn tcp_servers(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0, v1) = self.0; + DumpResponseBuilder((v0, v1, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`web_rtc_transport_ids` field](DumpResponse#structfield.web_rtc_transport_ids). + #[inline] + #[allow(clippy::type_complexity)] + pub fn web_rtc_transport_ids( + self, + value: T3, + ) -> DumpResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0, v1, v2) = self.0; + DumpResponseBuilder((v0, v1, v2, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`local_ice_username_fragments` field](DumpResponse#structfield.local_ice_username_fragments). + #[inline] + #[allow(clippy::type_complexity)] + pub fn local_ice_username_fragments( + self, + value: T4, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`tuple_hashes` field](DumpResponse#structfield.tuple_hashes). + #[inline] + #[allow(clippy::type_complexity)] + pub fn tuple_hashes( + self, + value: T5, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0, v1, v2, v3, v4) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for CloseTransportRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAs<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for CloseTransportRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOptional<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset - for CloseTransportRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T4: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOffset + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - CloseTransportRequest::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1, v2, v3, v4, v5) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3, v4, v5) } } - /// Reference to a deserialized [CloseTransportRequest]. + /// Reference to a deserialized [DumpResponse]. #[derive(Copy, Clone)] - pub struct CloseTransportRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CloseTransportRequestRef<'a> { - /// Getter for the [`transport_id` field](CloseTransportRequest#structfield.transport_id). + impl<'a> DumpResponseRef<'a> { + /// Getter for the [`id` field](DumpResponse#structfield.id). #[inline] - pub fn transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "DumpResponse", "id") + } + + /// Getter for the [`udp_sockets` field](DumpResponse#structfield.udp_sockets). + #[inline] + pub fn udp_sockets( + &self, + ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> + { + self.0.access_required(1, "DumpResponse", "udp_sockets") + } + + /// Getter for the [`tcp_servers` field](DumpResponse#structfield.tcp_servers). + #[inline] + pub fn tcp_servers( + &self, + ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> + { + self.0.access_required(2, "DumpResponse", "tcp_servers") + } + + /// Getter for the [`web_rtc_transport_ids` field](DumpResponse#structfield.web_rtc_transport_ids). + #[inline] + pub fn web_rtc_transport_ids( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { self.0 - .access_required(0, "CloseTransportRequest", "transport_id") + .access_required(3, "DumpResponse", "web_rtc_transport_ids") + } + + /// Getter for the [`local_ice_username_fragments` field](DumpResponse#structfield.local_ice_username_fragments). + #[inline] + pub fn local_ice_username_fragments( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0 + .access_required(4, "DumpResponse", "local_ice_username_fragments") + } + + /// Getter for the [`tuple_hashes` field](DumpResponse#structfield.tuple_hashes). + #[inline] + pub fn tuple_hashes( + &self, + ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> + { + self.0.access_required(5, "DumpResponse", "tuple_hashes") } } - impl<'a> ::core::fmt::Debug for CloseTransportRequestRef<'a> { + impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CloseTransportRequestRef"); - f.field("transport_id", &self.transport_id()); + let mut f = f.debug_struct("DumpResponseRef"); + f.field("id", &self.id()); + f.field("udp_sockets", &self.udp_sockets()); + f.field("tcp_servers", &self.tcp_servers()); + f.field("web_rtc_transport_ids", &self.web_rtc_transport_ids()); + f.field( + "local_ice_username_fragments", + &self.local_ice_username_fragments(), + ); + f.field("tuple_hashes", &self.tuple_hashes()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CloseTransportRequest { + impl<'a> ::core::convert::TryFrom> for DumpResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CloseTransportRequestRef<'a>) -> ::planus::Result { + fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - transport_id: ::core::convert::TryInto::try_into(value.transport_id()?)?, + id: ::core::convert::TryInto::try_into(value.id()?)?, + udp_sockets: value.udp_sockets()?.to_vec_result()?, + tcp_servers: value.tcp_servers()?.to_vec_result()?, + web_rtc_transport_ids: value.web_rtc_transport_ids()?.to_vec_result()?, + local_ice_username_fragments: value + .local_ice_username_fragments()? + .to_vec_result()?, + tuple_hashes: value.tuple_hashes()?.to_vec_result()?, }) } } - impl<'a> ::planus::TableRead<'a> for CloseTransportRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -62704,7 +64625,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CloseTransportRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -62714,7 +64635,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CloseTransportRequestRef]", + "[DumpResponseRef]", "get", buffer.offset_from_start, ) @@ -62722,8 +64643,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for CloseTransportRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -62732,7 +64653,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -62747,7 +64668,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CloseTransportRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -62757,19 +64678,20 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[CloseTransportRequestRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) }) } } - - /// The table `CloseRtpObserverRequest` in the namespace `FBS.Router` + } + /// The namespace `FBS.Producer` + /// + /// Generated from these locations: + /// * File `../worker/fbs/producer.fbs` + pub mod producer { + /// The table `EnableTraceEventRequest` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `CloseRtpObserverRequest` in the file `../worker/fbs/router.fbs:57` + /// * Table `EnableTraceEventRequest` in the file `../worker/fbs/producer.fbs:6` #[derive( Clone, Debug, @@ -62781,52 +64703,52 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct CloseRtpObserverRequest { - /// The field `rtp_observer_id` in the table `CloseRtpObserverRequest` - pub rtp_observer_id: ::planus::alloc::string::String, + pub struct EnableTraceEventRequest { + /// The field `events` in the table `EnableTraceEventRequest` + pub events: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, } - impl CloseRtpObserverRequest { - /// Creates a [CloseRtpObserverRequestBuilder] for serializing an instance of this table. + impl EnableTraceEventRequest { + /// Creates a [EnableTraceEventRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> CloseRtpObserverRequestBuilder<()> { - CloseRtpObserverRequestBuilder(()) + pub fn builder() -> EnableTraceEventRequestBuilder<()> { + EnableTraceEventRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_rtp_observer_id: impl ::planus::WriteAs<::planus::Offset>, + field_events: impl ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, ) -> ::planus::Offset { - let prepared_rtp_observer_id = field_rtp_observer_id.prepare(builder); + let prepared_events = field_events.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_rtp_observer_id); + object_writer.write::<_, _, 4>(&prepared_events); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for CloseRtpObserverRequest { + impl ::planus::WriteAs<::planus::Offset> for EnableTraceEventRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for CloseRtpObserverRequest + impl ::planus::WriteAsOptional<::planus::Offset> + for EnableTraceEventRequest { type Prepared = ::planus::Offset; @@ -62834,135 +64756,137 @@ mod root { fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for CloseRtpObserverRequest { + impl ::planus::WriteAsOffset for EnableTraceEventRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - CloseRtpObserverRequest::create(builder, &self.rtp_observer_id) + ) -> ::planus::Offset { + EnableTraceEventRequest::create(builder, &self.events) } } - /// Builder for serializing an instance of the [CloseRtpObserverRequest] type. + /// Builder for serializing an instance of the [EnableTraceEventRequest] type. /// - /// Can be created using the [CloseRtpObserverRequest::builder] method. + /// Can be created using the [EnableTraceEventRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct CloseRtpObserverRequestBuilder(State); + pub struct EnableTraceEventRequestBuilder(State); - impl CloseRtpObserverRequestBuilder<()> { - /// Setter for the [`rtp_observer_id` field](CloseRtpObserverRequest#structfield.rtp_observer_id). + impl EnableTraceEventRequestBuilder<()> { + /// Setter for the [`events` field](EnableTraceEventRequest#structfield.events). #[inline] #[allow(clippy::type_complexity)] - pub fn rtp_observer_id(self, value: T0) -> CloseRtpObserverRequestBuilder<(T0,)> + pub fn events(self, value: T0) -> EnableTraceEventRequestBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, { - CloseRtpObserverRequestBuilder((value,)) + EnableTraceEventRequestBuilder((value,)) } } - impl CloseRtpObserverRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [CloseRtpObserverRequest]. + impl EnableTraceEventRequestBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [EnableTraceEventRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for CloseRtpObserverRequestBuilder<(T0,)> + impl]>>> + ::planus::WriteAs<::planus::Offset> + for EnableTraceEventRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for CloseRtpObserverRequestBuilder<(T0,)> + impl]>>> + ::planus::WriteAsOptional<::planus::Offset> + for EnableTraceEventRequestBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset - for CloseRtpObserverRequestBuilder<(T0,)> + impl]>>> + ::planus::WriteAsOffset + for EnableTraceEventRequestBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0,) = &self.0; - CloseRtpObserverRequest::create(builder, v0) + EnableTraceEventRequest::create(builder, v0) } } - /// Reference to a deserialized [CloseRtpObserverRequest]. + /// Reference to a deserialized [EnableTraceEventRequest]. #[derive(Copy, Clone)] - pub struct CloseRtpObserverRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct EnableTraceEventRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> CloseRtpObserverRequestRef<'a> { - /// Getter for the [`rtp_observer_id` field](CloseRtpObserverRequest#structfield.rtp_observer_id). + impl<'a> EnableTraceEventRequestRef<'a> { + /// Getter for the [`events` field](EnableTraceEventRequest#structfield.events). #[inline] - pub fn rtp_observer_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + pub fn events( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { self.0 - .access_required(0, "CloseRtpObserverRequest", "rtp_observer_id") + .access_required(0, "EnableTraceEventRequest", "events") } } - impl<'a> ::core::fmt::Debug for CloseRtpObserverRequestRef<'a> { + impl<'a> ::core::fmt::Debug for EnableTraceEventRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("CloseRtpObserverRequestRef"); - f.field("rtp_observer_id", &self.rtp_observer_id()); + let mut f = f.debug_struct("EnableTraceEventRequestRef"); + f.field("events", &self.events()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for CloseRtpObserverRequest { + impl<'a> ::core::convert::TryFrom> for EnableTraceEventRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: CloseRtpObserverRequestRef<'a>) -> ::planus::Result { + fn try_from(value: EnableTraceEventRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - rtp_observer_id: ::core::convert::TryInto::try_into( - value.rtp_observer_id()?, - )?, + events: value.events()?.to_vec_result()?, }) } } - impl<'a> ::planus::TableRead<'a> for CloseRtpObserverRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for EnableTraceEventRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -62974,7 +64898,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for CloseRtpObserverRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for EnableTraceEventRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -62984,7 +64908,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[CloseRtpObserverRequestRef]", + "[EnableTraceEventRequestRef]", "get", buffer.offset_from_start, ) @@ -62992,8 +64916,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for CloseRtpObserverRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for EnableTraceEventRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -63002,7 +64926,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -63017,7 +64941,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for CloseRtpObserverRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for EnableTraceEventRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -63028,69 +64952,118 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[CloseRtpObserverRequestRef]", + "[EnableTraceEventRequestRef]", "read_as_root", 0, ) }) } } - } - /// The namespace `FBS.WebRtcServer` - /// - /// Generated from these locations: - /// * File `../worker/fbs/webRtcServer.fbs` - pub mod web_rtc_server { - /// The table `IpPort` in the namespace `FBS.WebRtcServer` + + /// The table `DumpResponse` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `IpPort` in the file `../worker/fbs/webRtcServer.fbs:5` + /// * Table `DumpResponse` in the file `../worker/fbs/producer.fbs:10` #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] - pub struct IpPort { - /// The field `ip` in the table `IpPort` - pub ip: ::planus::alloc::string::String, - /// The field `port` in the table `IpPort` - pub port: u16, + pub struct DumpResponse { + /// The field `id` in the table `DumpResponse` + pub id: ::planus::alloc::string::String, + /// The field `kind` in the table `DumpResponse` + pub kind: super::rtp_parameters::MediaKind, + /// The field `type` in the table `DumpResponse` + pub type_: ::planus::alloc::string::String, + /// The field `rtp_parameters` in the table `DumpResponse` + pub rtp_parameters: + ::planus::alloc::boxed::Box, + /// The field `rtp_mapping` in the table `DumpResponse` + pub rtp_mapping: ::planus::alloc::boxed::Box, + /// The field `rtp_streams` in the table `DumpResponse` + pub rtp_streams: + ::core::option::Option<::planus::alloc::vec::Vec>, + /// The field `trace_event_types` in the table `DumpResponse` + pub trace_event_types: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + /// The field `paused` in the table `DumpResponse` + pub paused: bool, } - impl IpPort { - /// Creates a [IpPortBuilder] for serializing an instance of this table. + impl DumpResponse { + /// Creates a [DumpResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> IpPortBuilder<()> { - IpPortBuilder(()) + pub fn builder() -> DumpResponseBuilder<()> { + DumpResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ip: impl ::planus::WriteAs<::planus::Offset>, - field_port: impl ::planus::WriteAsDefault, + field_id: impl ::planus::WriteAs<::planus::Offset>, + field_kind: impl ::planus::WriteAsDefault< + super::rtp_parameters::MediaKind, + super::rtp_parameters::MediaKind, + >, + field_type_: impl ::planus::WriteAs<::planus::Offset>, + field_rtp_parameters: impl ::planus::WriteAs< + ::planus::Offset, + >, + field_rtp_mapping: impl ::planus::WriteAs< + ::planus::Offset, + >, + field_rtp_streams: impl ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + field_trace_event_types: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_paused: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_ip = field_ip.prepare(builder); - let prepared_port = field_port.prepare(builder, &0); + let prepared_id = field_id.prepare(builder); + let prepared_kind = + field_kind.prepare(builder, &super::rtp_parameters::MediaKind::All); + let prepared_type_ = field_type_.prepare(builder); + let prepared_rtp_parameters = field_rtp_parameters.prepare(builder); + let prepared_rtp_mapping = field_rtp_mapping.prepare(builder); + let prepared_rtp_streams = field_rtp_streams.prepare(builder); + let prepared_trace_event_types = field_trace_event_types.prepare(builder); + let prepared_paused = field_paused.prepare(builder, &false); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<20> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - if prepared_port.is_some() { - table_writer.write_entry::(1); + table_writer.write_entry::<::planus::Offset>(2); + table_writer + .write_entry::<::planus::Offset>(3); + table_writer + .write_entry::<::planus::Offset>(4); + if prepared_rtp_streams.is_some() { + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(5); + } + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(6); + if prepared_kind.is_some() { + table_writer.write_entry::(1); + } + if prepared_paused.is_some() { + table_writer.write_entry::(7); } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_ip); - if let ::core::option::Option::Some(prepared_port) = prepared_port { - object_writer.write::<_, _, 2>(&prepared_port); + object_writer.write::<_, _, 4>(&prepared_id); + object_writer.write::<_, _, 4>(&prepared_type_); + object_writer.write::<_, _, 4>(&prepared_rtp_parameters); + object_writer.write::<_, _, 4>(&prepared_rtp_mapping); + if let ::core::option::Option::Some(prepared_rtp_streams) = + prepared_rtp_streams + { + object_writer.write::<_, _, 4>(&prepared_rtp_streams); + } + object_writer.write::<_, _, 4>(&prepared_trace_event_types); + if let ::core::option::Option::Some(prepared_kind) = prepared_kind { + object_writer.write::<_, _, 1>(&prepared_kind); + } + if let ::core::option::Option::Some(prepared_paused) = prepared_paused { + object_writer.write::<_, _, 1>(&prepared_paused); } }); } @@ -63098,79 +65071,207 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for IpPort { + impl ::planus::WriteAs<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for IpPort { + impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for IpPort { + impl ::planus::WriteAsOffset for DumpResponse { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - IpPort::create(builder, &self.ip, self.port) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + DumpResponse::create( + builder, + &self.id, + self.kind, + &self.type_, + &self.rtp_parameters, + &self.rtp_mapping, + &self.rtp_streams, + &self.trace_event_types, + self.paused, + ) } } - /// Builder for serializing an instance of the [IpPort] type. + /// Builder for serializing an instance of the [DumpResponse] type. /// - /// Can be created using the [IpPort::builder] method. + /// Can be created using the [DumpResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct IpPortBuilder(State); + pub struct DumpResponseBuilder(State); - impl IpPortBuilder<()> { - /// Setter for the [`ip` field](IpPort#structfield.ip). + impl DumpResponseBuilder<()> { + /// Setter for the [`id` field](DumpResponse#structfield.id). #[inline] #[allow(clippy::type_complexity)] - pub fn ip(self, value: T0) -> IpPortBuilder<(T0,)> + pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - IpPortBuilder((value,)) + DumpResponseBuilder((value,)) } } - impl IpPortBuilder<(T0,)> { - /// Setter for the [`port` field](IpPort#structfield.port). + impl DumpResponseBuilder<(T0,)> { + /// Setter for the [`kind` field](DumpResponse#structfield.kind). #[inline] #[allow(clippy::type_complexity)] - pub fn port(self, value: T1) -> IpPortBuilder<(T0, T1)> + pub fn kind(self, value: T1) -> DumpResponseBuilder<(T0, T1)> where - T1: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault< + super::rtp_parameters::MediaKind, + super::rtp_parameters::MediaKind, + >, { let (v0,) = self.0; - IpPortBuilder((v0, value)) + DumpResponseBuilder((v0, value)) } - /// Sets the [`port` field](IpPort#structfield.port) to the default value. + /// Sets the [`kind` field](DumpResponse#structfield.kind) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn port_as_default(self) -> IpPortBuilder<(T0, ::planus::DefaultValue)> { - self.port(::planus::DefaultValue) + pub fn kind_as_default(self) -> DumpResponseBuilder<(T0, ::planus::DefaultValue)> { + self.kind(::planus::DefaultValue) } } - impl IpPortBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IpPort]. + impl DumpResponseBuilder<(T0, T1)> { + /// Setter for the [`type` field](DumpResponse#structfield.type_). #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + #[allow(clippy::type_complexity)] + pub fn type_(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> where - Self: ::planus::WriteAsOffset, + T2: ::planus::WriteAs<::planus::Offset>, + { + let (v0, v1) = self.0; + DumpResponseBuilder((v0, v1, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`rtp_parameters` field](DumpResponse#structfield.rtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_parameters(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAs<::planus::Offset>, + { + let (v0, v1, v2) = self.0; + DumpResponseBuilder((v0, v1, v2, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`rtp_mapping` field](DumpResponse#structfield.rtp_mapping). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_mapping(self, value: T4) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAs<::planus::Offset>, + { + let (v0, v1, v2, v3) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`rtp_streams` field](DumpResponse#structfield.rtp_streams). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_streams( + self, + value: T5, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + { + let (v0, v1, v2, v3, v4) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, value)) + } + + /// Sets the [`rtp_streams` field](DumpResponse#structfield.rtp_streams) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtp_streams_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, ())> { + self.rtp_streams(()) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { + /// Setter for the [`trace_event_types` field](DumpResponse#structfield.trace_event_types). + #[inline] + #[allow(clippy::type_complexity)] + pub fn trace_event_types( + self, + value: T6, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> + where + T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + { + let (v0, v1, v2, v3, v4, v5) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, v5, value)) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { + /// Setter for the [`paused` field](DumpResponse#structfield.paused). + #[inline] + #[allow(clippy::type_complexity)] + pub fn paused( + self, + value: T7, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + where + T7: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4, v5, v6) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + } + + /// Sets the [`paused` field](DumpResponse#structfield.paused) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn paused_as_default( + self, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)> + { + self.paused(::planus::DefaultValue) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + #[inline] + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -63178,85 +65279,210 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> for IpPortBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault< + super::rtp_parameters::MediaKind, + super::rtp_parameters::MediaKind, + >, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAs<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T7: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> for IpPortBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault< + super::rtp_parameters::MediaKind, + super::rtp_parameters::MediaKind, + >, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAs<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T7: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset for IpPortBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault< + super::rtp_parameters::MediaKind, + super::rtp_parameters::MediaKind, + >, + T2: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAs<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T7: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0, v1) = &self.0; - IpPort::create(builder, v0, v1) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0, v1, v2, v3, v4, v5, v6, v7) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3, v4, v5, v6, v7) } } - /// Reference to a deserialized [IpPort]. + /// Reference to a deserialized [DumpResponse]. #[derive(Copy, Clone)] - pub struct IpPortRef<'a>(::planus::table_reader::Table<'a>); + pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> IpPortRef<'a> { - /// Getter for the [`ip` field](IpPort#structfield.ip). + impl<'a> DumpResponseRef<'a> { + /// Getter for the [`id` field](DumpResponse#structfield.id). #[inline] - pub fn ip(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "IpPort", "ip") + pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "DumpResponse", "id") } - /// Getter for the [`port` field](IpPort#structfield.port). + /// Getter for the [`kind` field](DumpResponse#structfield.kind). #[inline] - pub fn port(&self) -> ::planus::Result { - ::core::result::Result::Ok(self.0.access(1, "IpPort", "port")?.unwrap_or(0)) + pub fn kind(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "DumpResponse", "kind")? + .unwrap_or(super::rtp_parameters::MediaKind::All), + ) + } + + /// Getter for the [`type` field](DumpResponse#structfield.type_). + #[inline] + pub fn type_(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(2, "DumpResponse", "type_") + } + + /// Getter for the [`rtp_parameters` field](DumpResponse#structfield.rtp_parameters). + #[inline] + pub fn rtp_parameters( + &self, + ) -> ::planus::Result> { + self.0.access_required(3, "DumpResponse", "rtp_parameters") + } + + /// Getter for the [`rtp_mapping` field](DumpResponse#structfield.rtp_mapping). + #[inline] + pub fn rtp_mapping( + &self, + ) -> ::planus::Result> { + self.0.access_required(4, "DumpResponse", "rtp_mapping") + } + + /// Getter for the [`rtp_streams` field](DumpResponse#structfield.rtp_streams). + #[inline] + pub fn rtp_streams( + &self, + ) -> ::planus::Result< + ::core::option::Option< + ::planus::Vector<'a, ::planus::Result>>, + >, + > { + self.0.access(5, "DumpResponse", "rtp_streams") + } + + /// Getter for the [`trace_event_types` field](DumpResponse#structfield.trace_event_types). + #[inline] + pub fn trace_event_types( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + > { + self.0 + .access_required(6, "DumpResponse", "trace_event_types") + } + + /// Getter for the [`paused` field](DumpResponse#structfield.paused). + #[inline] + pub fn paused(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0.access(7, "DumpResponse", "paused")?.unwrap_or(false), + ) } } - impl<'a> ::core::fmt::Debug for IpPortRef<'a> { + impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("IpPortRef"); - f.field("ip", &self.ip()); - f.field("port", &self.port()); + let mut f = f.debug_struct("DumpResponseRef"); + f.field("id", &self.id()); + f.field("kind", &self.kind()); + f.field("type_", &self.type_()); + f.field("rtp_parameters", &self.rtp_parameters()); + f.field("rtp_mapping", &self.rtp_mapping()); + if let ::core::option::Option::Some(field_rtp_streams) = + self.rtp_streams().transpose() + { + f.field("rtp_streams", &field_rtp_streams); + } + f.field("trace_event_types", &self.trace_event_types()); + f.field("paused", &self.paused()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for IpPort { + impl<'a> ::core::convert::TryFrom> for DumpResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: IpPortRef<'a>) -> ::planus::Result { + fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ip: ::core::convert::TryInto::try_into(value.ip()?)?, - port: ::core::convert::TryInto::try_into(value.port()?)?, + id: ::core::convert::TryInto::try_into(value.id()?)?, + kind: ::core::convert::TryInto::try_into(value.kind()?)?, + type_: ::core::convert::TryInto::try_into(value.type_()?)?, + rtp_parameters: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.rtp_parameters()?)?, + ), + rtp_mapping: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.rtp_mapping()?)?, + ), + rtp_streams: if let ::core::option::Option::Some(rtp_streams) = + value.rtp_streams()? + { + ::core::option::Option::Some(rtp_streams.to_vec_result()?) + } else { + ::core::option::Option::None + }, + trace_event_types: value.trace_event_types()?.to_vec_result()?, + paused: ::core::convert::TryInto::try_into(value.paused()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for IpPortRef<'a> { + impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -63268,7 +65494,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for IpPortRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -63278,7 +65504,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[IpPortRef]", + "[DumpResponseRef]", "get", buffer.offset_from_start, ) @@ -63286,8 +65512,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for IpPort { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -63296,7 +65522,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -63311,7 +65537,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for IpPortRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -63321,256 +65547,238 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[IpPortRef]", "read_as_root", 0) + error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) }) } } - /// The table `IceUserNameFragment` in the namespace `FBS.WebRtcServer` + /// The table `GetStatsResponse` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `IceUserNameFragment` in the file `../worker/fbs/webRtcServer.fbs:10` + /// * Table `GetStatsResponse` in the file `../worker/fbs/producer.fbs:21` #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] - pub struct IceUserNameFragment { - /// The field `local_ice_username_fragment` in the table `IceUserNameFragment` - pub local_ice_username_fragment: ::planus::alloc::string::String, - /// The field `web_rtc_transport_id` in the table `IceUserNameFragment` - pub web_rtc_transport_id: ::planus::alloc::string::String, + pub struct GetStatsResponse { + /// The field `stats` in the table `GetStatsResponse` + pub stats: + ::core::option::Option<::planus::alloc::vec::Vec>, } - impl IceUserNameFragment { - /// Creates a [IceUserNameFragmentBuilder] for serializing an instance of this table. + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for GetStatsResponse { + fn default() -> Self { + Self { + stats: ::core::default::Default::default(), + } + } + } + + impl GetStatsResponse { + /// Creates a [GetStatsResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> IceUserNameFragmentBuilder<()> { - IceUserNameFragmentBuilder(()) + pub fn builder() -> GetStatsResponseBuilder<()> { + GetStatsResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_local_ice_username_fragment: impl ::planus::WriteAs<::planus::Offset>, - field_web_rtc_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_stats: impl ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, ) -> ::planus::Offset { - let prepared_local_ice_username_fragment = - field_local_ice_username_fragment.prepare(builder); - let prepared_web_rtc_transport_id = field_web_rtc_transport_id.prepare(builder); + let prepared_stats = field_stats.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); + if prepared_stats.is_some() { + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_local_ice_username_fragment); - object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_id); + if let ::core::option::Option::Some(prepared_stats) = prepared_stats { + object_writer.write::<_, _, 4>(&prepared_stats); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for IceUserNameFragment { + impl ::planus::WriteAs<::planus::Offset> for GetStatsResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for IceUserNameFragment { + impl ::planus::WriteAsOptional<::planus::Offset> for GetStatsResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for IceUserNameFragment { + impl ::planus::WriteAsOffset for GetStatsResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - IceUserNameFragment::create( - builder, - &self.local_ice_username_fragment, - &self.web_rtc_transport_id, - ) + ) -> ::planus::Offset { + GetStatsResponse::create(builder, &self.stats) } } - /// Builder for serializing an instance of the [IceUserNameFragment] type. + /// Builder for serializing an instance of the [GetStatsResponse] type. /// - /// Can be created using the [IceUserNameFragment::builder] method. + /// Can be created using the [GetStatsResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct IceUserNameFragmentBuilder(State); + pub struct GetStatsResponseBuilder(State); - impl IceUserNameFragmentBuilder<()> { - /// Setter for the [`local_ice_username_fragment` field](IceUserNameFragment#structfield.local_ice_username_fragment). + impl GetStatsResponseBuilder<()> { + /// Setter for the [`stats` field](GetStatsResponse#structfield.stats). #[inline] #[allow(clippy::type_complexity)] - pub fn local_ice_username_fragment( - self, - value: T0, - ) -> IceUserNameFragmentBuilder<(T0,)> + pub fn stats(self, value: T0) -> GetStatsResponseBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, { - IceUserNameFragmentBuilder((value,)) + GetStatsResponseBuilder((value,)) } - } - impl IceUserNameFragmentBuilder<(T0,)> { - /// Setter for the [`web_rtc_transport_id` field](IceUserNameFragment#structfield.web_rtc_transport_id). + /// Sets the [`stats` field](GetStatsResponse#structfield.stats) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_transport_id( - self, - value: T1, - ) -> IceUserNameFragmentBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset>, - { - let (v0,) = self.0; - IceUserNameFragmentBuilder((v0, value)) + pub fn stats_as_null(self) -> GetStatsResponseBuilder<((),)> { + self.stats(()) } } - impl IceUserNameFragmentBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IceUserNameFragment]. + impl GetStatsResponseBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [GetStatsResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for IceUserNameFragmentBuilder<(T0, T1)> + T0: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAs<::planus::Offset> + for GetStatsResponseBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for IceUserNameFragmentBuilder<(T0, T1)> + T0: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for GetStatsResponseBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset - for IceUserNameFragmentBuilder<(T0, T1)> + T0: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOffset for GetStatsResponseBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - IceUserNameFragment::create(builder, v0, v1) + ) -> ::planus::Offset { + let (v0,) = &self.0; + GetStatsResponse::create(builder, v0) } } - /// Reference to a deserialized [IceUserNameFragment]. + /// Reference to a deserialized [GetStatsResponse]. #[derive(Copy, Clone)] - pub struct IceUserNameFragmentRef<'a>(::planus::table_reader::Table<'a>); + pub struct GetStatsResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> IceUserNameFragmentRef<'a> { - /// Getter for the [`local_ice_username_fragment` field](IceUserNameFragment#structfield.local_ice_username_fragment). + impl<'a> GetStatsResponseRef<'a> { + /// Getter for the [`stats` field](GetStatsResponse#structfield.stats). #[inline] - pub fn local_ice_username_fragment( + pub fn stats( &self, - ) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "IceUserNameFragment", "local_ice_username_fragment") - } - - /// Getter for the [`web_rtc_transport_id` field](IceUserNameFragment#structfield.web_rtc_transport_id). - #[inline] - pub fn web_rtc_transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(1, "IceUserNameFragment", "web_rtc_transport_id") + ) -> ::planus::Result< + ::core::option::Option< + ::planus::Vector<'a, ::planus::Result>>, + >, + > { + self.0.access(0, "GetStatsResponse", "stats") } } - impl<'a> ::core::fmt::Debug for IceUserNameFragmentRef<'a> { + impl<'a> ::core::fmt::Debug for GetStatsResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("IceUserNameFragmentRef"); - f.field( - "local_ice_username_fragment", - &self.local_ice_username_fragment(), - ); - f.field("web_rtc_transport_id", &self.web_rtc_transport_id()); + let mut f = f.debug_struct("GetStatsResponseRef"); + if let ::core::option::Option::Some(field_stats) = self.stats().transpose() { + f.field("stats", &field_stats); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for IceUserNameFragment { + impl<'a> ::core::convert::TryFrom> for GetStatsResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: IceUserNameFragmentRef<'a>) -> ::planus::Result { + fn try_from(value: GetStatsResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - local_ice_username_fragment: ::core::convert::TryInto::try_into( - value.local_ice_username_fragment()?, - )?, - web_rtc_transport_id: ::core::convert::TryInto::try_into( - value.web_rtc_transport_id()?, - )?, + stats: if let ::core::option::Option::Some(stats) = value.stats()? { + ::core::option::Option::Some(stats.to_vec_result()?) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for IceUserNameFragmentRef<'a> { + impl<'a> ::planus::TableRead<'a> for GetStatsResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -63582,7 +65790,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for IceUserNameFragmentRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for GetStatsResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -63592,7 +65800,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[IceUserNameFragmentRef]", + "[GetStatsResponseRef]", "get", buffer.offset_from_start, ) @@ -63600,8 +65808,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for IceUserNameFragment { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for GetStatsResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -63610,7 +65818,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -63625,7 +65833,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for IceUserNameFragmentRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for GetStatsResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -63635,19 +65843,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[IceUserNameFragmentRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[GetStatsResponseRef]", "read_as_root", 0) }) } } - /// The table `TupleHash` in the namespace `FBS.WebRtcServer` + /// The table `SendNotification` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `TupleHash` in the file `../worker/fbs/webRtcServer.fbs:15` + /// * Table `SendNotification` in the file `../worker/fbs/producer.fbs:25` #[derive( Clone, Debug, @@ -63659,231 +65863,180 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct TupleHash { - /// The field `local_ice_username_fragment` in the table `TupleHash` - pub local_ice_username_fragment: u64, - /// The field `web_rtc_transport_id` in the table `TupleHash` - pub web_rtc_transport_id: ::planus::alloc::string::String, + pub struct SendNotification { + /// The field `data` in the table `SendNotification` + pub data: ::planus::alloc::vec::Vec, } - impl TupleHash { - /// Creates a [TupleHashBuilder] for serializing an instance of this table. + impl SendNotification { + /// Creates a [SendNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> TupleHashBuilder<()> { - TupleHashBuilder(()) + pub fn builder() -> SendNotificationBuilder<()> { + SendNotificationBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_local_ice_username_fragment: impl ::planus::WriteAsDefault, - field_web_rtc_transport_id: impl ::planus::WriteAs<::planus::Offset>, + field_data: impl ::planus::WriteAs<::planus::Offset<[u8]>>, ) -> ::planus::Offset { - let prepared_local_ice_username_fragment = - field_local_ice_username_fragment.prepare(builder, &0); - let prepared_web_rtc_transport_id = field_web_rtc_transport_id.prepare(builder); + let prepared_data = field_data.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_local_ice_username_fragment.is_some() { - table_writer.write_entry::(0); - } - table_writer.write_entry::<::planus::Offset>(1); + table_writer.write_entry::<::planus::Offset<[u8]>>(0); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some( - prepared_local_ice_username_fragment, - ) = prepared_local_ice_username_fragment - { - object_writer - .write::<_, _, 8>(&prepared_local_ice_username_fragment); - } - object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_id); + object_writer.write::<_, _, 4>(&prepared_data); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for TupleHash { + impl ::planus::WriteAs<::planus::Offset> for SendNotification { type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for TupleHash { + impl ::planus::WriteAsOptional<::planus::Offset> for SendNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for TupleHash { + impl ::planus::WriteAsOffset for SendNotification { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - TupleHash::create( - builder, - self.local_ice_username_fragment, - &self.web_rtc_transport_id, - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + SendNotification::create(builder, &self.data) } } - /// Builder for serializing an instance of the [TupleHash] type. + /// Builder for serializing an instance of the [SendNotification] type. /// - /// Can be created using the [TupleHash::builder] method. + /// Can be created using the [SendNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct TupleHashBuilder(State); - - impl TupleHashBuilder<()> { - /// Setter for the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment). - #[inline] - #[allow(clippy::type_complexity)] - pub fn local_ice_username_fragment(self, value: T0) -> TupleHashBuilder<(T0,)> - where - T0: ::planus::WriteAsDefault, - { - TupleHashBuilder((value,)) - } - - /// Sets the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn local_ice_username_fragment_as_default( - self, - ) -> TupleHashBuilder<(::planus::DefaultValue,)> { - self.local_ice_username_fragment(::planus::DefaultValue) - } - } + pub struct SendNotificationBuilder(State); - impl TupleHashBuilder<(T0,)> { - /// Setter for the [`web_rtc_transport_id` field](TupleHash#structfield.web_rtc_transport_id). + impl SendNotificationBuilder<()> { + /// Setter for the [`data` field](SendNotification#structfield.data). #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_transport_id(self, value: T1) -> TupleHashBuilder<(T0, T1)> + pub fn data(self, value: T0) -> SendNotificationBuilder<(T0,)> where - T1: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAs<::planus::Offset<[u8]>>, { - let (v0,) = self.0; - TupleHashBuilder((v0, value)) + SendNotificationBuilder((value,)) } } - impl TupleHashBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TupleHash]. + impl SendNotificationBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [SendNotification]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> for TupleHashBuilder<(T0, T1)> + impl>> + ::planus::WriteAs<::planus::Offset> + for SendNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for TupleHashBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for SendNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset for TupleHashBuilder<(T0, T1)> + impl>> + ::planus::WriteAsOffset for SendNotificationBuilder<(T0,)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0, v1) = &self.0; - TupleHash::create(builder, v0, v1) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + SendNotification::create(builder, v0) } } - /// Reference to a deserialized [TupleHash]. + /// Reference to a deserialized [SendNotification]. #[derive(Copy, Clone)] - pub struct TupleHashRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> TupleHashRef<'a> { - /// Getter for the [`local_ice_username_fragment` field](TupleHash#structfield.local_ice_username_fragment). - #[inline] - pub fn local_ice_username_fragment(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(0, "TupleHash", "local_ice_username_fragment")? - .unwrap_or(0), - ) - } + pub struct SendNotificationRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`web_rtc_transport_id` field](TupleHash#structfield.web_rtc_transport_id). + impl<'a> SendNotificationRef<'a> { + /// Getter for the [`data` field](SendNotification#structfield.data). #[inline] - pub fn web_rtc_transport_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(1, "TupleHash", "web_rtc_transport_id") + pub fn data(&self) -> ::planus::Result<&'a [u8]> { + self.0.access_required(0, "SendNotification", "data") } } - impl<'a> ::core::fmt::Debug for TupleHashRef<'a> { + impl<'a> ::core::fmt::Debug for SendNotificationRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("TupleHashRef"); - f.field( - "local_ice_username_fragment", - &self.local_ice_username_fragment(), - ); - f.field("web_rtc_transport_id", &self.web_rtc_transport_id()); + let mut f = f.debug_struct("SendNotificationRef"); + f.field("data", &self.data()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for TupleHash { + impl<'a> ::core::convert::TryFrom> for SendNotification { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: TupleHashRef<'a>) -> ::planus::Result { + fn try_from(value: SendNotificationRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - local_ice_username_fragment: ::core::convert::TryInto::try_into( - value.local_ice_username_fragment()?, - )?, - web_rtc_transport_id: ::core::convert::TryInto::try_into( - value.web_rtc_transport_id()?, - )?, + data: value.data()?.to_vec(), }) } } - impl<'a> ::planus::TableRead<'a> for TupleHashRef<'a> { + impl<'a> ::planus::TableRead<'a> for SendNotificationRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -63895,7 +66048,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for TupleHashRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for SendNotificationRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -63905,7 +66058,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[TupleHashRef]", + "[SendNotificationRef]", "get", buffer.offset_from_start, ) @@ -63913,8 +66066,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for TupleHash { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for SendNotification { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -63923,7 +66076,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -63938,7 +66091,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for TupleHashRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for SendNotificationRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -63948,15 +66101,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[TupleHashRef]", "read_as_root", 0) + error_kind.with_error_location("[SendNotificationRef]", "read_as_root", 0) }) } } - /// The table `DumpResponse` in the namespace `FBS.WebRtcServer` + /// The table `Score` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/webRtcServer.fbs:20` + /// * Table `Score` in the file `../worker/fbs/producer.fbs:31` #[derive( Clone, Debug, @@ -63968,400 +66121,280 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct DumpResponse { - /// The field `id` in the table `DumpResponse` - pub id: ::planus::alloc::string::String, - /// The field `udp_sockets` in the table `DumpResponse` - pub udp_sockets: ::planus::alloc::vec::Vec, - /// The field `tcp_servers` in the table `DumpResponse` - pub tcp_servers: ::planus::alloc::vec::Vec, - /// The field `web_rtc_transport_ids` in the table `DumpResponse` - pub web_rtc_transport_ids: - ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `local_ice_username_fragments` in the table `DumpResponse` - pub local_ice_username_fragments: - ::planus::alloc::vec::Vec, - /// The field `tuple_hashes` in the table `DumpResponse` - pub tuple_hashes: ::planus::alloc::vec::Vec, + pub struct Score { + /// The field `ssrc` in the table `Score` + pub ssrc: u32, + /// The field `rid` in the table `Score` + pub rid: ::core::option::Option<::planus::alloc::string::String>, + /// The field `score` in the table `Score` + pub score: u8, } - impl DumpResponse { - /// Creates a [DumpResponseBuilder] for serializing an instance of this table. + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Score { + fn default() -> Self { + Self { + ssrc: 0, + rid: ::core::default::Default::default(), + score: 0, + } + } + } + + impl Score { + /// Creates a [ScoreBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> DumpResponseBuilder<()> { - DumpResponseBuilder(()) + pub fn builder() -> ScoreBuilder<()> { + ScoreBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_id: impl ::planus::WriteAs<::planus::Offset>, - field_udp_sockets: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_tcp_servers: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_web_rtc_transport_ids: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_local_ice_username_fragments: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_tuple_hashes: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, + field_ssrc: impl ::planus::WriteAsDefault, + field_rid: impl ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + field_score: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_id = field_id.prepare(builder); - let prepared_udp_sockets = field_udp_sockets.prepare(builder); - let prepared_tcp_servers = field_tcp_servers.prepare(builder); - let prepared_web_rtc_transport_ids = - field_web_rtc_transport_ids.prepare(builder); - let prepared_local_ice_username_fragments = - field_local_ice_username_fragments.prepare(builder); - let prepared_tuple_hashes = field_tuple_hashes.prepare(builder); + let prepared_ssrc = field_ssrc.prepare(builder, &0); + let prepared_rid = field_rid.prepare(builder); + let prepared_score = field_score.prepare(builder, &0); - let mut table_writer: ::planus::table_writer::TableWriter<16> = + let mut table_writer: ::planus::table_writer::TableWriter<10> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer - .write_entry::<::planus::Offset<[::planus::Offset]>>(1); - table_writer - .write_entry::<::planus::Offset<[::planus::Offset]>>(2); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(3); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(4); - table_writer - .write_entry::<::planus::Offset<[::planus::Offset]>>(5); + if prepared_ssrc.is_some() { + table_writer.write_entry::(0); + } + if prepared_rid.is_some() { + table_writer.write_entry::<::planus::Offset>(1); + } + if prepared_score.is_some() { + table_writer.write_entry::(2); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_id); - object_writer.write::<_, _, 4>(&prepared_udp_sockets); - object_writer.write::<_, _, 4>(&prepared_tcp_servers); - object_writer.write::<_, _, 4>(&prepared_web_rtc_transport_ids); - object_writer.write::<_, _, 4>(&prepared_local_ice_username_fragments); - object_writer.write::<_, _, 4>(&prepared_tuple_hashes); + if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { + object_writer.write::<_, _, 4>(&prepared_ssrc); + } + if let ::core::option::Option::Some(prepared_rid) = prepared_rid { + object_writer.write::<_, _, 4>(&prepared_rid); + } + if let ::core::option::Option::Some(prepared_score) = prepared_score { + object_writer.write::<_, _, 1>(&prepared_score); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + impl ::planus::WriteAs<::planus::Offset> for Score { type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + impl ::planus::WriteAsOptional<::planus::Offset> for Score { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for DumpResponse { + impl ::planus::WriteAsOffset for Score { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DumpResponse::create( - builder, - &self.id, - &self.udp_sockets, - &self.tcp_servers, - &self.web_rtc_transport_ids, - &self.local_ice_username_fragments, - &self.tuple_hashes, - ) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + Score::create(builder, self.ssrc, &self.rid, self.score) } } - /// Builder for serializing an instance of the [DumpResponse] type. + /// Builder for serializing an instance of the [Score] type. /// - /// Can be created using the [DumpResponse::builder] method. + /// Can be created using the [Score::builder] method. #[derive(Debug)] #[must_use] - pub struct DumpResponseBuilder(State); + pub struct ScoreBuilder(State); - impl DumpResponseBuilder<()> { - /// Setter for the [`id` field](DumpResponse#structfield.id). + impl ScoreBuilder<()> { + /// Setter for the [`ssrc` field](Score#structfield.ssrc). #[inline] #[allow(clippy::type_complexity)] - pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> + pub fn ssrc(self, value: T0) -> ScoreBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsDefault, { - DumpResponseBuilder((value,)) + ScoreBuilder((value,)) } - } - impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`udp_sockets` field](DumpResponse#structfield.udp_sockets). + /// Sets the [`ssrc` field](Score#structfield.ssrc) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn udp_sockets(self, value: T1) -> DumpResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0,) = self.0; - DumpResponseBuilder((v0, value)) + pub fn ssrc_as_default(self) -> ScoreBuilder<(::planus::DefaultValue,)> { + self.ssrc(::planus::DefaultValue) } } - impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`tcp_servers` field](DumpResponse#structfield.tcp_servers). + impl ScoreBuilder<(T0,)> { + /// Setter for the [`rid` field](Score#structfield.rid). #[inline] #[allow(clippy::type_complexity)] - pub fn tcp_servers(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> + pub fn rid(self, value: T1) -> ScoreBuilder<(T0, T1)> where - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, { - let (v0, v1) = self.0; - DumpResponseBuilder((v0, v1, value)) + let (v0,) = self.0; + ScoreBuilder((v0, value)) } - } - impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`web_rtc_transport_ids` field](DumpResponse#structfield.web_rtc_transport_ids). + /// Sets the [`rid` field](Score#structfield.rid) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn web_rtc_transport_ids( - self, - value: T3, - ) -> DumpResponseBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0, v1, v2) = self.0; - DumpResponseBuilder((v0, v1, v2, value)) + pub fn rid_as_null(self) -> ScoreBuilder<(T0, ())> { + self.rid(()) } } - impl DumpResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`local_ice_username_fragments` field](DumpResponse#structfield.local_ice_username_fragments). + impl ScoreBuilder<(T0, T1)> { + /// Setter for the [`score` field](Score#structfield.score). #[inline] #[allow(clippy::type_complexity)] - pub fn local_ice_username_fragments( - self, - value: T4, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> + pub fn score(self, value: T2) -> ScoreBuilder<(T0, T1, T2)> where - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, + T2: ::planus::WriteAsDefault, { - let (v0, v1, v2, v3) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, value)) + let (v0, v1) = self.0; + ScoreBuilder((v0, v1, value)) } - } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`tuple_hashes` field](DumpResponse#structfield.tuple_hashes). + /// Sets the [`score` field](Score#structfield.score) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn tuple_hashes( - self, - value: T5, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> - where - T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - let (v0, v1, v2, v3, v4) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, value)) + pub fn score_as_default(self) -> ScoreBuilder<(T0, T1, ::planus::DefaultValue)> { + self.score(::planus::DefaultValue) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + impl ScoreBuilder<(T0, T1, T2)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Score]. #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset + pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T2: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> for ScoreBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T2: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for ScoreBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T2: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOffset - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T2: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset for ScoreBuilder<(T0, T1, T2)> { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3, v4, v5) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + let (v0, v1, v2) = &self.0; + Score::create(builder, v0, v1, v2) } } - /// Reference to a deserialized [DumpResponse]. + /// Reference to a deserialized [Score]. #[derive(Copy, Clone)] - pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> DumpResponseRef<'a> { - /// Getter for the [`id` field](DumpResponse#structfield.id). - #[inline] - pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "DumpResponse", "id") - } + pub struct ScoreRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`udp_sockets` field](DumpResponse#structfield.udp_sockets). + impl<'a> ScoreRef<'a> { + /// Getter for the [`ssrc` field](Score#structfield.ssrc). #[inline] - pub fn udp_sockets( - &self, - ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> - { - self.0.access_required(1, "DumpResponse", "udp_sockets") + pub fn ssrc(&self) -> ::planus::Result { + ::core::result::Result::Ok(self.0.access(0, "Score", "ssrc")?.unwrap_or(0)) } - /// Getter for the [`tcp_servers` field](DumpResponse#structfield.tcp_servers). + /// Getter for the [`rid` field](Score#structfield.rid). #[inline] - pub fn tcp_servers( + pub fn rid( &self, - ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> + ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> { - self.0.access_required(2, "DumpResponse", "tcp_servers") - } - - /// Getter for the [`web_rtc_transport_ids` field](DumpResponse#structfield.web_rtc_transport_ids). - #[inline] - pub fn web_rtc_transport_ids( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0 - .access_required(3, "DumpResponse", "web_rtc_transport_ids") - } - - /// Getter for the [`local_ice_username_fragments` field](DumpResponse#structfield.local_ice_username_fragments). - #[inline] - pub fn local_ice_username_fragments( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0 - .access_required(4, "DumpResponse", "local_ice_username_fragments") + self.0.access(1, "Score", "rid") } - /// Getter for the [`tuple_hashes` field](DumpResponse#structfield.tuple_hashes). + /// Getter for the [`score` field](Score#structfield.score). #[inline] - pub fn tuple_hashes( - &self, - ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result>>> - { - self.0.access_required(5, "DumpResponse", "tuple_hashes") + pub fn score(&self) -> ::planus::Result { + ::core::result::Result::Ok(self.0.access(2, "Score", "score")?.unwrap_or(0)) } } - impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + impl<'a> ::core::fmt::Debug for ScoreRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DumpResponseRef"); - f.field("id", &self.id()); - f.field("udp_sockets", &self.udp_sockets()); - f.field("tcp_servers", &self.tcp_servers()); - f.field("web_rtc_transport_ids", &self.web_rtc_transport_ids()); - f.field( - "local_ice_username_fragments", - &self.local_ice_username_fragments(), - ); - f.field("tuple_hashes", &self.tuple_hashes()); + let mut f = f.debug_struct("ScoreRef"); + f.field("ssrc", &self.ssrc()); + if let ::core::option::Option::Some(field_rid) = self.rid().transpose() { + f.field("rid", &field_rid); + } + f.field("score", &self.score()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for DumpResponse { + impl<'a> ::core::convert::TryFrom> for Score { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - id: ::core::convert::TryInto::try_into(value.id()?)?, - udp_sockets: value.udp_sockets()?.to_vec_result()?, - tcp_servers: value.tcp_servers()?.to_vec_result()?, - web_rtc_transport_ids: value.web_rtc_transport_ids()?.to_vec_result()?, - local_ice_username_fragments: value - .local_ice_username_fragments()? - .to_vec_result()?, - tuple_hashes: value.tuple_hashes()?.to_vec_result()?, + fn try_from(value: ScoreRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, + rid: if let ::core::option::Option::Some(rid) = value.rid()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(rid)?) + } else { + ::core::option::Option::None + }, + score: ::core::convert::TryInto::try_into(value.score()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for ScoreRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -64373,7 +66406,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ScoreRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -64383,7 +66416,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[DumpResponseRef]", + "[ScoreRef]", "get", buffer.offset_from_start, ) @@ -64391,8 +66424,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for Score { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -64401,7 +66434,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -64416,7 +66449,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ScoreRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -64426,20 +66459,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + error_kind.with_error_location("[ScoreRef]", "read_as_root", 0) }) } } - } - /// The namespace `FBS.Producer` - /// - /// Generated from these locations: - /// * File `../worker/fbs/producer.fbs` - pub mod producer { - /// The table `EnableTraceEventRequest` in the namespace `FBS.Producer` + + /// The table `ScoreNotification` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `EnableTraceEventRequest` in the file `../worker/fbs/producer.fbs:6` + /// * Table `ScoreNotification` in the file `../worker/fbs/producer.fbs:37` #[derive( Clone, Debug, @@ -64451,190 +66479,220 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct EnableTraceEventRequest { - /// The field `events` in the table `EnableTraceEventRequest` - pub events: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, + pub struct ScoreNotification { + /// The field `scores` in the table `ScoreNotification` + pub scores: ::core::option::Option<::planus::alloc::vec::Vec>, } - impl EnableTraceEventRequest { - /// Creates a [EnableTraceEventRequestBuilder] for serializing an instance of this table. + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for ScoreNotification { + fn default() -> Self { + Self { + scores: ::core::default::Default::default(), + } + } + } + + impl ScoreNotification { + /// Creates a [ScoreNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> EnableTraceEventRequestBuilder<()> { - EnableTraceEventRequestBuilder(()) + pub fn builder() -> ScoreNotificationBuilder<()> { + ScoreNotificationBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_events: impl ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + field_scores: impl ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, ) -> ::planus::Offset { - let prepared_events = field_events.prepare(builder); + let prepared_scores = field_scores.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); + if prepared_scores.is_some() { + table_writer + .write_entry::<::planus::Offset<[::planus::Offset]>>(0); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_events); + if let ::core::option::Option::Some(prepared_scores) = prepared_scores { + object_writer.write::<_, _, 4>(&prepared_scores); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for EnableTraceEventRequest { + impl ::planus::WriteAs<::planus::Offset> for ScoreNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for EnableTraceEventRequest - { + impl ::planus::WriteAsOptional<::planus::Offset> for ScoreNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for EnableTraceEventRequest { + impl ::planus::WriteAsOffset for ScoreNotification { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - EnableTraceEventRequest::create(builder, &self.events) + ) -> ::planus::Offset { + ScoreNotification::create(builder, &self.scores) } } - /// Builder for serializing an instance of the [EnableTraceEventRequest] type. + /// Builder for serializing an instance of the [ScoreNotification] type. /// - /// Can be created using the [EnableTraceEventRequest::builder] method. + /// Can be created using the [ScoreNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct EnableTraceEventRequestBuilder(State); + pub struct ScoreNotificationBuilder(State); - impl EnableTraceEventRequestBuilder<()> { - /// Setter for the [`events` field](EnableTraceEventRequest#structfield.events). + impl ScoreNotificationBuilder<()> { + /// Setter for the [`scores` field](ScoreNotification#structfield.scores). #[inline] #[allow(clippy::type_complexity)] - pub fn events(self, value: T0) -> EnableTraceEventRequestBuilder<(T0,)> + pub fn scores(self, value: T0) -> ScoreNotificationBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T0: ::planus::WriteAsOptional< + ::planus::Offset<[::planus::Offset]>, + >, { - EnableTraceEventRequestBuilder((value,)) + ScoreNotificationBuilder((value,)) + } + + /// Sets the [`scores` field](ScoreNotification#structfield.scores) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn scores_as_null(self) -> ScoreNotificationBuilder<((),)> { + self.scores(()) } } - impl EnableTraceEventRequestBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [EnableTraceEventRequest]. + impl ScoreNotificationBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ScoreNotification]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl]>>> - ::planus::WriteAs<::planus::Offset> - for EnableTraceEventRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAs<::planus::Offset> + for ScoreNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl]>>> - ::planus::WriteAsOptional<::planus::Offset> - for EnableTraceEventRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOptional<::planus::Offset> + for ScoreNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl]>>> - ::planus::WriteAsOffset - for EnableTraceEventRequestBuilder<(T0,)> + impl< + T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, + > ::planus::WriteAsOffset for ScoreNotificationBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0,) = &self.0; - EnableTraceEventRequest::create(builder, v0) + ScoreNotification::create(builder, v0) } } - /// Reference to a deserialized [EnableTraceEventRequest]. + /// Reference to a deserialized [ScoreNotification]. #[derive(Copy, Clone)] - pub struct EnableTraceEventRequestRef<'a>(::planus::table_reader::Table<'a>); + pub struct ScoreNotificationRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> EnableTraceEventRequestRef<'a> { - /// Getter for the [`events` field](EnableTraceEventRequest#structfield.events). + impl<'a> ScoreNotificationRef<'a> { + /// Getter for the [`scores` field](ScoreNotification#structfield.scores). #[inline] - pub fn events( + pub fn scores( &self, ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, + ::core::option::Option< + ::planus::Vector<'a, ::planus::Result>>, + >, > { - self.0 - .access_required(0, "EnableTraceEventRequest", "events") + self.0.access(0, "ScoreNotification", "scores") } } - impl<'a> ::core::fmt::Debug for EnableTraceEventRequestRef<'a> { + impl<'a> ::core::fmt::Debug for ScoreNotificationRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("EnableTraceEventRequestRef"); - f.field("events", &self.events()); + let mut f = f.debug_struct("ScoreNotificationRef"); + if let ::core::option::Option::Some(field_scores) = self.scores().transpose() { + f.field("scores", &field_scores); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for EnableTraceEventRequest { + impl<'a> ::core::convert::TryFrom> for ScoreNotification { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: EnableTraceEventRequestRef<'a>) -> ::planus::Result { + fn try_from(value: ScoreNotificationRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - events: value.events()?.to_vec_result()?, + scores: if let ::core::option::Option::Some(scores) = value.scores()? { + ::core::option::Option::Some(scores.to_vec_result()?) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for EnableTraceEventRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for ScoreNotificationRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -64646,7 +66704,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for EnableTraceEventRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ScoreNotificationRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -64656,7 +66714,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[EnableTraceEventRequestRef]", + "[ScoreNotificationRef]", "get", buffer.offset_from_start, ) @@ -64664,8 +66722,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for EnableTraceEventRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ScoreNotification { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -64674,7 +66732,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -64689,7 +66747,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for EnableTraceEventRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ScoreNotificationRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -64699,119 +66757,88 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[EnableTraceEventRequestRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[ScoreNotificationRef]", "read_as_root", 0) }) } } - /// The table `DumpResponse` in the namespace `FBS.Producer` + /// The table `VideoOrientationChangeNotification` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/producer.fbs:10` + /// * Table `VideoOrientationChangeNotification` in the file `../worker/fbs/producer.fbs:41` #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] - pub struct DumpResponse { - /// The field `id` in the table `DumpResponse` - pub id: ::planus::alloc::string::String, - /// The field `kind` in the table `DumpResponse` - pub kind: super::rtp_parameters::MediaKind, - /// The field `type` in the table `DumpResponse` - pub type_: ::planus::alloc::string::String, - /// The field `rtp_parameters` in the table `DumpResponse` - pub rtp_parameters: - ::planus::alloc::boxed::Box, - /// The field `rtp_mapping` in the table `DumpResponse` - pub rtp_mapping: ::planus::alloc::boxed::Box, - /// The field `rtp_streams` in the table `DumpResponse` - pub rtp_streams: - ::core::option::Option<::planus::alloc::vec::Vec>, - /// The field `trace_event_types` in the table `DumpResponse` - pub trace_event_types: ::planus::alloc::vec::Vec<::planus::alloc::string::String>, - /// The field `paused` in the table `DumpResponse` - pub paused: bool, + pub struct VideoOrientationChangeNotification { + /// The field `camera` in the table `VideoOrientationChangeNotification` + pub camera: bool, + /// The field `flip` in the table `VideoOrientationChangeNotification` + pub flip: bool, + /// The field `rotation` in the table `VideoOrientationChangeNotification` + pub rotation: u16, } - impl DumpResponse { - /// Creates a [DumpResponseBuilder] for serializing an instance of this table. + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for VideoOrientationChangeNotification { + fn default() -> Self { + Self { + camera: false, + flip: false, + rotation: 0, + } + } + } + + impl VideoOrientationChangeNotification { + /// Creates a [VideoOrientationChangeNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> DumpResponseBuilder<()> { - DumpResponseBuilder(()) + pub fn builder() -> VideoOrientationChangeNotificationBuilder<()> { + VideoOrientationChangeNotificationBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_id: impl ::planus::WriteAs<::planus::Offset>, - field_kind: impl ::planus::WriteAsDefault< - super::rtp_parameters::MediaKind, - super::rtp_parameters::MediaKind, - >, - field_type_: impl ::planus::WriteAs<::planus::Offset>, - field_rtp_parameters: impl ::planus::WriteAs< - ::planus::Offset, - >, - field_rtp_mapping: impl ::planus::WriteAs< - ::planus::Offset, - >, - field_rtp_streams: impl ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - field_trace_event_types: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_paused: impl ::planus::WriteAsDefault, + field_camera: impl ::planus::WriteAsDefault, + field_flip: impl ::planus::WriteAsDefault, + field_rotation: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_id = field_id.prepare(builder); - let prepared_kind = - field_kind.prepare(builder, &super::rtp_parameters::MediaKind::All); - let prepared_type_ = field_type_.prepare(builder); - let prepared_rtp_parameters = field_rtp_parameters.prepare(builder); - let prepared_rtp_mapping = field_rtp_mapping.prepare(builder); - let prepared_rtp_streams = field_rtp_streams.prepare(builder); - let prepared_trace_event_types = field_trace_event_types.prepare(builder); - let prepared_paused = field_paused.prepare(builder, &false); + let prepared_camera = field_camera.prepare(builder, &false); + let prepared_flip = field_flip.prepare(builder, &false); + let prepared_rotation = field_rotation.prepare(builder, &0); - let mut table_writer: ::planus::table_writer::TableWriter<20> = + let mut table_writer: ::planus::table_writer::TableWriter<10> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(2); - table_writer - .write_entry::<::planus::Offset>(3); - table_writer - .write_entry::<::planus::Offset>(4); - if prepared_rtp_streams.is_some() { - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(5); + if prepared_rotation.is_some() { + table_writer.write_entry::(2); } - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(6); - if prepared_kind.is_some() { - table_writer.write_entry::(1); + if prepared_camera.is_some() { + table_writer.write_entry::(0); } - if prepared_paused.is_some() { - table_writer.write_entry::(7); + if prepared_flip.is_some() { + table_writer.write_entry::(1); } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_id); - object_writer.write::<_, _, 4>(&prepared_type_); - object_writer.write::<_, _, 4>(&prepared_rtp_parameters); - object_writer.write::<_, _, 4>(&prepared_rtp_mapping); - if let ::core::option::Option::Some(prepared_rtp_streams) = - prepared_rtp_streams + if let ::core::option::Option::Some(prepared_rotation) = + prepared_rotation { - object_writer.write::<_, _, 4>(&prepared_rtp_streams); + object_writer.write::<_, _, 2>(&prepared_rotation); } - object_writer.write::<_, _, 4>(&prepared_trace_event_types); - if let ::core::option::Option::Some(prepared_kind) = prepared_kind { - object_writer.write::<_, _, 1>(&prepared_kind); + if let ::core::option::Option::Some(prepared_camera) = prepared_camera { + object_writer.write::<_, _, 1>(&prepared_camera); } - if let ::core::option::Option::Some(prepared_paused) = prepared_paused { - object_writer.write::<_, _, 1>(&prepared_paused); + if let ::core::option::Option::Some(prepared_flip) = prepared_flip { + object_writer.write::<_, _, 1>(&prepared_flip); } }); } @@ -64819,418 +66846,270 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + impl ::planus::WriteAs<::planus::Offset> + for VideoOrientationChangeNotification + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + impl ::planus::WriteAsOptional<::planus::Offset> + for VideoOrientationChangeNotification + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for DumpResponse { + impl ::planus::WriteAsOffset + for VideoOrientationChangeNotification + { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DumpResponse::create( + ) -> ::planus::Offset { + VideoOrientationChangeNotification::create( builder, - &self.id, - self.kind, - &self.type_, - &self.rtp_parameters, - &self.rtp_mapping, - &self.rtp_streams, - &self.trace_event_types, - self.paused, + self.camera, + self.flip, + self.rotation, ) } } - /// Builder for serializing an instance of the [DumpResponse] type. + /// Builder for serializing an instance of the [VideoOrientationChangeNotification] type. /// - /// Can be created using the [DumpResponse::builder] method. + /// Can be created using the [VideoOrientationChangeNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct DumpResponseBuilder(State); - - impl DumpResponseBuilder<()> { - /// Setter for the [`id` field](DumpResponse#structfield.id). - #[inline] - #[allow(clippy::type_complexity)] - pub fn id(self, value: T0) -> DumpResponseBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - DumpResponseBuilder((value,)) - } - } - - impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`kind` field](DumpResponse#structfield.kind). - #[inline] - #[allow(clippy::type_complexity)] - pub fn kind(self, value: T1) -> DumpResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault< - super::rtp_parameters::MediaKind, - super::rtp_parameters::MediaKind, - >, - { - let (v0,) = self.0; - DumpResponseBuilder((v0, value)) - } - - /// Sets the [`kind` field](DumpResponse#structfield.kind) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn kind_as_default(self) -> DumpResponseBuilder<(T0, ::planus::DefaultValue)> { - self.kind(::planus::DefaultValue) - } - } - - impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`type` field](DumpResponse#structfield.type_). - #[inline] - #[allow(clippy::type_complexity)] - pub fn type_(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAs<::planus::Offset>, - { - let (v0, v1) = self.0; - DumpResponseBuilder((v0, v1, value)) - } - } + pub struct VideoOrientationChangeNotificationBuilder(State); - impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`rtp_parameters` field](DumpResponse#structfield.rtp_parameters). + impl VideoOrientationChangeNotificationBuilder<()> { + /// Setter for the [`camera` field](VideoOrientationChangeNotification#structfield.camera). #[inline] #[allow(clippy::type_complexity)] - pub fn rtp_parameters(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> + pub fn camera( + self, + value: T0, + ) -> VideoOrientationChangeNotificationBuilder<(T0,)> where - T3: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsDefault, { - let (v0, v1, v2) = self.0; - DumpResponseBuilder((v0, v1, v2, value)) + VideoOrientationChangeNotificationBuilder((value,)) } - } - impl DumpResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`rtp_mapping` field](DumpResponse#structfield.rtp_mapping). + /// Sets the [`camera` field](VideoOrientationChangeNotification#structfield.camera) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn rtp_mapping(self, value: T4) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> - where - T4: ::planus::WriteAs<::planus::Offset>, + pub fn camera_as_default( + self, + ) -> VideoOrientationChangeNotificationBuilder<(::planus::DefaultValue,)> { - let (v0, v1, v2, v3) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, value)) + self.camera(::planus::DefaultValue) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`rtp_streams` field](DumpResponse#structfield.rtp_streams). + impl VideoOrientationChangeNotificationBuilder<(T0,)> { + /// Setter for the [`flip` field](VideoOrientationChangeNotification#structfield.flip). #[inline] #[allow(clippy::type_complexity)] - pub fn rtp_streams( + pub fn flip( self, - value: T5, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + value: T1, + ) -> VideoOrientationChangeNotificationBuilder<(T0, T1)> where - T5: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, + T1: ::planus::WriteAsDefault, { - let (v0, v1, v2, v3, v4) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, value)) - } - - /// Sets the [`rtp_streams` field](DumpResponse#structfield.rtp_streams) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtp_streams_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, ())> { - self.rtp_streams(()) + let (v0,) = self.0; + VideoOrientationChangeNotificationBuilder((v0, value)) } - } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Setter for the [`trace_event_types` field](DumpResponse#structfield.trace_event_types). + /// Sets the [`flip` field](VideoOrientationChangeNotification#structfield.flip) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn trace_event_types( + pub fn flip_as_default( self, - value: T6, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> - where - T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + ) -> VideoOrientationChangeNotificationBuilder<(T0, ::planus::DefaultValue)> { - let (v0, v1, v2, v3, v4, v5) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, v5, value)) + self.flip(::planus::DefaultValue) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - /// Setter for the [`paused` field](DumpResponse#structfield.paused). + impl VideoOrientationChangeNotificationBuilder<(T0, T1)> { + /// Setter for the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation). #[inline] #[allow(clippy::type_complexity)] - pub fn paused( + pub fn rotation( self, - value: T7, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + value: T2, + ) -> VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> where - T7: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, { - let (v0, v1, v2, v3, v4, v5, v6) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) + let (v0, v1) = self.0; + VideoOrientationChangeNotificationBuilder((v0, v1, value)) } - /// Sets the [`paused` field](DumpResponse#structfield.paused) to the default value. + /// Sets the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn paused_as_default( + pub fn rotation_as_default( self, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)> + ) -> VideoOrientationChangeNotificationBuilder<(T0, T1, ::planus::DefaultValue)> { - self.paused(::planus::DefaultValue) + self.rotation(::planus::DefaultValue) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + impl VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [VideoOrientationChangeNotification]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault< - super::rtp_parameters::MediaKind, - super::rtp_parameters::MediaKind, - >, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, - T5: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T7: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + > + ::planus::WriteAs<::planus::Offset> + for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault< - super::rtp_parameters::MediaKind, - super::rtp_parameters::MediaKind, - >, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, - T5: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T7: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + > + ::planus::WriteAsOptional<::planus::Offset> + for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault< - super::rtp_parameters::MediaKind, - super::rtp_parameters::MediaKind, - >, - T2: ::planus::WriteAs<::planus::Offset>, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, - T5: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - T6: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T7: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset + for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5, v6, v7) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3, v4, v5, v6, v7) + ) -> ::planus::Offset { + let (v0, v1, v2) = &self.0; + VideoOrientationChangeNotification::create(builder, v0, v1, v2) } } - /// Reference to a deserialized [DumpResponse]. + /// Reference to a deserialized [VideoOrientationChangeNotification]. #[derive(Copy, Clone)] - pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> DumpResponseRef<'a> { - /// Getter for the [`id` field](DumpResponse#structfield.id). - #[inline] - pub fn id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "DumpResponse", "id") - } + pub struct VideoOrientationChangeNotificationRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`kind` field](DumpResponse#structfield.kind). + impl<'a> VideoOrientationChangeNotificationRef<'a> { + /// Getter for the [`camera` field](VideoOrientationChangeNotification#structfield.camera). #[inline] - pub fn kind(&self) -> ::planus::Result { + pub fn camera(&self) -> ::planus::Result { ::core::result::Result::Ok( self.0 - .access(1, "DumpResponse", "kind")? - .unwrap_or(super::rtp_parameters::MediaKind::All), + .access(0, "VideoOrientationChangeNotification", "camera")? + .unwrap_or(false), ) } - /// Getter for the [`type` field](DumpResponse#structfield.type_). - #[inline] - pub fn type_(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(2, "DumpResponse", "type_") - } - - /// Getter for the [`rtp_parameters` field](DumpResponse#structfield.rtp_parameters). - #[inline] - pub fn rtp_parameters( - &self, - ) -> ::planus::Result> { - self.0.access_required(3, "DumpResponse", "rtp_parameters") - } - - /// Getter for the [`rtp_mapping` field](DumpResponse#structfield.rtp_mapping). - #[inline] - pub fn rtp_mapping( - &self, - ) -> ::planus::Result> { - self.0.access_required(4, "DumpResponse", "rtp_mapping") - } - - /// Getter for the [`rtp_streams` field](DumpResponse#structfield.rtp_streams). - #[inline] - pub fn rtp_streams( - &self, - ) -> ::planus::Result< - ::core::option::Option< - ::planus::Vector<'a, ::planus::Result>>, - >, - > { - self.0.access(5, "DumpResponse", "rtp_streams") - } - - /// Getter for the [`trace_event_types` field](DumpResponse#structfield.trace_event_types). + /// Getter for the [`flip` field](VideoOrientationChangeNotification#structfield.flip). #[inline] - pub fn trace_event_types( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result<&'a ::core::primitive::str>>, - > { - self.0 - .access_required(6, "DumpResponse", "trace_event_types") + pub fn flip(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "VideoOrientationChangeNotification", "flip")? + .unwrap_or(false), + ) } - /// Getter for the [`paused` field](DumpResponse#structfield.paused). + /// Getter for the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation). #[inline] - pub fn paused(&self) -> ::planus::Result { + pub fn rotation(&self) -> ::planus::Result { ::core::result::Result::Ok( - self.0.access(7, "DumpResponse", "paused")?.unwrap_or(false), + self.0 + .access(2, "VideoOrientationChangeNotification", "rotation")? + .unwrap_or(0), ) } } - impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + impl<'a> ::core::fmt::Debug for VideoOrientationChangeNotificationRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DumpResponseRef"); - f.field("id", &self.id()); - f.field("kind", &self.kind()); - f.field("type_", &self.type_()); - f.field("rtp_parameters", &self.rtp_parameters()); - f.field("rtp_mapping", &self.rtp_mapping()); - if let ::core::option::Option::Some(field_rtp_streams) = - self.rtp_streams().transpose() - { - f.field("rtp_streams", &field_rtp_streams); - } - f.field("trace_event_types", &self.trace_event_types()); - f.field("paused", &self.paused()); + let mut f = f.debug_struct("VideoOrientationChangeNotificationRef"); + f.field("camera", &self.camera()); + f.field("flip", &self.flip()); + f.field("rotation", &self.rotation()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for DumpResponse { + impl<'a> ::core::convert::TryFrom> + for VideoOrientationChangeNotification + { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { + fn try_from( + value: VideoOrientationChangeNotificationRef<'a>, + ) -> ::planus::Result { ::core::result::Result::Ok(Self { - id: ::core::convert::TryInto::try_into(value.id()?)?, - kind: ::core::convert::TryInto::try_into(value.kind()?)?, - type_: ::core::convert::TryInto::try_into(value.type_()?)?, - rtp_parameters: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.rtp_parameters()?)?, - ), - rtp_mapping: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.rtp_mapping()?)?, - ), - rtp_streams: if let ::core::option::Option::Some(rtp_streams) = - value.rtp_streams()? - { - ::core::option::Option::Some(rtp_streams.to_vec_result()?) - } else { - ::core::option::Option::None - }, - trace_event_types: value.trace_event_types()?.to_vec_result()?, - paused: ::core::convert::TryInto::try_into(value.paused()?)?, + camera: ::core::convert::TryInto::try_into(value.camera()?)?, + flip: ::core::convert::TryInto::try_into(value.flip()?)?, + rotation: ::core::convert::TryInto::try_into(value.rotation()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for VideoOrientationChangeNotificationRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -65242,7 +67121,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for VideoOrientationChangeNotificationRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -65252,7 +67131,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[DumpResponseRef]", + "[VideoOrientationChangeNotificationRef]", "get", buffer.offset_from_start, ) @@ -65260,8 +67139,10 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> + for VideoOrientationChangeNotification + { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -65270,7 +67151,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -65285,7 +67166,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for VideoOrientationChangeNotificationRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -65295,311 +67176,372 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + error_kind.with_error_location( + "[VideoOrientationChangeNotificationRef]", + "read_as_root", + 0, + ) }) } } - /// The table `GetStatsResponse` in the namespace `FBS.Producer` + /// The enum `TraceType` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `GetStatsResponse` in the file `../worker/fbs/producer.fbs:21` + /// * Enum `TraceType` in the file `../worker/fbs/producer.fbs:47` #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] - pub struct GetStatsResponse { - /// The field `stats` in the table `GetStatsResponse` - pub stats: - ::core::option::Option<::planus::alloc::vec::Vec>, + #[repr(u8)] + pub enum TraceType { + /// The variant `KEYFRAME` in the enum `TraceType` + Keyframe = 0, + + /// The variant `FIR` in the enum `TraceType` + Fir = 1, + + /// The variant `NACK` in the enum `TraceType` + Nack = 2, + + /// The variant `PLI` in the enum `TraceType` + Pli = 3, + + /// The variant `RTP` in the enum `TraceType` + Rtp = 4, } - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for GetStatsResponse { - fn default() -> Self { - Self { - stats: ::core::default::Default::default(), + impl TraceType { + /// Array containing all valid variants of TraceType + pub const ENUM_VALUES: [Self; 5] = + [Self::Keyframe, Self::Fir, Self::Nack, Self::Pli, Self::Rtp]; + } + + impl ::core::convert::TryFrom for TraceType { + type Error = ::planus::errors::UnknownEnumTagKind; + #[inline] + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(TraceType::Keyframe), + 1 => ::core::result::Result::Ok(TraceType::Fir), + 2 => ::core::result::Result::Ok(TraceType::Nack), + 3 => ::core::result::Result::Ok(TraceType::Pli), + 4 => ::core::result::Result::Ok(TraceType::Rtp), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), } } } - impl GetStatsResponse { - /// Creates a [GetStatsResponseBuilder] for serializing an instance of this table. + impl ::core::convert::From for u8 { #[inline] - pub fn builder() -> GetStatsResponseBuilder<()> { - GetStatsResponseBuilder(()) + fn from(value: TraceType) -> Self { + value as u8 } + } - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_stats: impl ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - ) -> ::planus::Offset { - let prepared_stats = field_stats.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - if prepared_stats.is_some() { - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); - } + impl ::planus::Primitive for TraceType { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } - unsafe { - table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_stats) = prepared_stats { - object_writer.write::<_, _, 4>(&prepared_stats); - } - }); - } - builder.current_offset() + impl ::planus::WriteAsPrimitive for TraceType { + #[inline] + fn write( + &self, + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl ::planus::WriteAs<::planus::Offset> for GetStatsResponse { - type Prepared = ::planus::Offset; + impl ::planus::WriteAs for TraceType { + type Prepared = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> TraceType { + *self } } - impl ::planus::WriteAsOptional<::planus::Offset> for GetStatsResponse { - type Prepared = ::planus::Offset; + impl ::planus::WriteAsDefault for TraceType { + type Prepared = Self; #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + _builder: &mut ::planus::Builder, + default: &TraceType, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - impl ::planus::WriteAsOffset for GetStatsResponse { + impl ::planus::WriteAsOptional for TraceType { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - GetStatsResponse::create(builder, &self.stats) + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - /// Builder for serializing an instance of the [GetStatsResponse] type. - /// - /// Can be created using the [GetStatsResponse::builder] method. - #[derive(Debug)] - #[must_use] - pub struct GetStatsResponseBuilder(State); + impl<'buf> ::planus::TableRead<'buf> for TraceType { + #[inline] + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) + } + } - impl GetStatsResponseBuilder<()> { - /// Setter for the [`stats` field](GetStatsResponse#structfield.stats). + impl<'buf> ::planus::VectorReadInner<'buf> for TraceType { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - #[allow(clippy::type_complexity)] - pub fn stats(self, value: T0) -> GetStatsResponseBuilder<(T0,)> - where - T0: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { - GetStatsResponseBuilder((value,)) + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "TraceType", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } + } + + impl ::planus::VectorWrite for TraceType { + const STRIDE: usize = 1; + + type Value = Self; - /// Sets the [`stats` field](GetStatsResponse#structfield.stats) to null. #[inline] - #[allow(clippy::type_complexity)] - pub fn stats_as_null(self) -> GetStatsResponseBuilder<((),)> { - self.stats(()) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } - } - impl GetStatsResponseBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [GetStatsResponse]. #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) + unsafe fn write_values( + values: &[Self], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - i as u32, + ); + } } } - impl< - T0: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - > ::planus::WriteAs<::planus::Offset> - for GetStatsResponseBuilder<(T0,)> - { - type Prepared = ::planus::Offset; + /// The enum `TraceDirection` in the namespace `FBS.Producer` + /// + /// Generated from these locations: + /// * Enum `TraceDirection` in the file `../worker/fbs/producer.fbs:49` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum TraceDirection { + /// The variant `DIRECTION_IN` in the enum `TraceDirection` + DirectionIn = 0, + + /// The variant `DIRECTION_OUT` in the enum `TraceDirection` + DirectionOut = 1, + } + + impl TraceDirection { + /// Array containing all valid variants of TraceDirection + pub const ENUM_VALUES: [Self; 2] = [Self::DirectionIn, Self::DirectionOut]; + } + + impl ::core::convert::TryFrom for TraceDirection { + type Error = ::planus::errors::UnknownEnumTagKind; + #[inline] + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(TraceDirection::DirectionIn), + 1 => ::core::result::Result::Ok(TraceDirection::DirectionOut), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } + } + } + impl ::core::convert::From for u8 { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + fn from(value: TraceDirection) -> Self { + value as u8 } } - impl< - T0: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - > ::planus::WriteAsOptional<::planus::Offset> - for GetStatsResponseBuilder<(T0,)> - { - type Prepared = ::planus::Offset; + impl ::planus::Primitive for TraceDirection { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } + impl ::planus::WriteAsPrimitive for TraceDirection { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl< - T0: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, - > ::planus::WriteAsOffset for GetStatsResponseBuilder<(T0,)> - { + impl ::planus::WriteAs for TraceDirection { + type Prepared = Self; + #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - GetStatsResponse::create(builder, v0) + fn prepare(&self, _builder: &mut ::planus::Builder) -> TraceDirection { + *self } } - /// Reference to a deserialized [GetStatsResponse]. - #[derive(Copy, Clone)] - pub struct GetStatsResponseRef<'a>(::planus::table_reader::Table<'a>); + impl ::planus::WriteAsDefault for TraceDirection { + type Prepared = Self; - impl<'a> GetStatsResponseRef<'a> { - /// Getter for the [`stats` field](GetStatsResponse#structfield.stats). #[inline] - pub fn stats( + fn prepare( &self, - ) -> ::planus::Result< - ::core::option::Option< - ::planus::Vector<'a, ::planus::Result>>, - >, - > { - self.0.access(0, "GetStatsResponse", "stats") - } - } - - impl<'a> ::core::fmt::Debug for GetStatsResponseRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("GetStatsResponseRef"); - if let ::core::option::Option::Some(field_stats) = self.stats().transpose() { - f.field("stats", &field_stats); + _builder: &mut ::planus::Builder, + default: &TraceDirection, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) } - f.finish() } } - impl<'a> ::core::convert::TryFrom> for GetStatsResponse { - type Error = ::planus::Error; + impl ::planus::WriteAsOptional for TraceDirection { + type Prepared = Self; - #[allow(unreachable_code)] - fn try_from(value: GetStatsResponseRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - stats: if let ::core::option::Option::Some(stats) = value.stats()? { - ::core::option::Option::Some(stats.to_vec_result()?) - } else { - ::core::option::Option::None - }, - }) + #[inline] + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl<'a> ::planus::TableRead<'a> for GetStatsResponseRef<'a> { + impl<'buf> ::planus::TableRead<'buf> for TraceDirection { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl<'a> ::planus::VectorReadInner<'a> for GetStatsResponseRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - + impl<'buf> ::planus::VectorReadInner<'buf> for TraceDirection { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; + #[inline] unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { error_kind.with_error_location( - "[GetStatsResponseRef]", - "get", + "TraceDirection", + "VectorRead::from_buffer", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite<::planus::Offset> for GetStatsResponse { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for TraceDirection { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for GetStatsResponseRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[GetStatsResponseRef]", "read_as_root", 0) - }) - } - } - - /// The table `SendNotification` in the namespace `FBS.Producer` + /// The union `TraceInfo` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `SendNotification` in the file `../worker/fbs/producer.fbs:25` + /// * Union `TraceInfo` in the file `../worker/fbs/producer.fbs:51` #[derive( Clone, Debug, @@ -65611,253 +67553,327 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct SendNotification { - /// The field `data` in the table `SendNotification` - pub data: ::planus::alloc::vec::Vec, + pub enum TraceInfo { + /// The variant of type `KeyFrameTraceInfo` in the union `TraceInfo` + KeyFrameTraceInfo(::planus::alloc::boxed::Box), + + /// The variant of type `FirTraceInfo` in the union `TraceInfo` + FirTraceInfo(::planus::alloc::boxed::Box), + + /// The variant of type `PliTraceInfo` in the union `TraceInfo` + PliTraceInfo(::planus::alloc::boxed::Box), + + /// The variant of type `RtpTraceInfo` in the union `TraceInfo` + RtpTraceInfo(::planus::alloc::boxed::Box), } - impl SendNotification { - /// Creates a [SendNotificationBuilder] for serializing an instance of this table. + impl TraceInfo { + /// Creates a [TraceInfoBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> SendNotificationBuilder<()> { - SendNotificationBuilder(()) + pub fn builder() -> TraceInfoBuilder<::planus::Uninitialized> { + TraceInfoBuilder(::planus::Uninitialized) } - #[allow(clippy::too_many_arguments)] - pub fn create( + #[inline] + pub fn create_key_frame_trace_info( builder: &mut ::planus::Builder, - field_data: impl ::planus::WriteAs<::planus::Offset<[u8]>>, - ) -> ::planus::Offset { - let prepared_data = field_data.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset<[u8]>>(0); + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + } - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_data); - }); - } - builder.current_offset() + #[inline] + pub fn create_fir_trace_info( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) } - } - impl ::planus::WriteAs<::planus::Offset> for SendNotification { - type Prepared = ::planus::Offset; + #[inline] + pub fn create_pli_trace_info( + builder: &mut ::planus::Builder, + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + } #[inline] - fn prepare( - &self, + pub fn create_rtp_trace_info( builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptional<::planus::Offset> for SendNotification { - type Prepared = ::planus::Offset; - + impl ::planus::WriteAsUnion for TraceInfo { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + match self { + Self::KeyFrameTraceInfo(value) => { + Self::create_key_frame_trace_info(builder, value) + } + Self::FirTraceInfo(value) => Self::create_fir_trace_info(builder, value), + Self::PliTraceInfo(value) => Self::create_pli_trace_info(builder, value), + Self::RtpTraceInfo(value) => Self::create_rtp_trace_info(builder, value), + } } } - impl ::planus::WriteAsOffset for SendNotification { + impl ::planus::WriteAsOptionalUnion for TraceInfo { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - SendNotification::create(builder, &self.data) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - /// Builder for serializing an instance of the [SendNotification] type. + /// Builder for serializing an instance of the [TraceInfo] type. /// - /// Can be created using the [SendNotification::builder] method. + /// Can be created using the [TraceInfo::builder] method. #[derive(Debug)] #[must_use] - pub struct SendNotificationBuilder(State); + pub struct TraceInfoBuilder(T); - impl SendNotificationBuilder<()> { - /// Setter for the [`data` field](SendNotification#structfield.data). + impl TraceInfoBuilder<::planus::Uninitialized> { + /// Creates an instance of the [`KeyFrameTraceInfo` variant](TraceInfo#variant.KeyFrameTraceInfo). #[inline] - #[allow(clippy::type_complexity)] - pub fn data(self, value: T0) -> SendNotificationBuilder<(T0,)> + pub fn key_frame_trace_info( + self, + value: T, + ) -> TraceInfoBuilder<::planus::Initialized<1, T>> where - T0: ::planus::WriteAs<::planus::Offset<[u8]>>, + T: ::planus::WriteAsOffset, { - SendNotificationBuilder((value,)) + TraceInfoBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`FirTraceInfo` variant](TraceInfo#variant.FirTraceInfo). + #[inline] + pub fn fir_trace_info( + self, + value: T, + ) -> TraceInfoBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { + TraceInfoBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`PliTraceInfo` variant](TraceInfo#variant.PliTraceInfo). + #[inline] + pub fn pli_trace_info( + self, + value: T, + ) -> TraceInfoBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + TraceInfoBuilder(::planus::Initialized(value)) + } + + /// Creates an instance of the [`RtpTraceInfo` variant](TraceInfo#variant.RtpTraceInfo). + #[inline] + pub fn rtp_trace_info( + self, + value: T, + ) -> TraceInfoBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + TraceInfoBuilder(::planus::Initialized(value)) } } - impl SendNotificationBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [SendNotification]. + impl TraceInfoBuilder<::planus::Initialized> { + /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [TraceInfo]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::UnionOffset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsUnion, { - ::planus::WriteAsOffset::prepare(&self, builder) + ::planus::WriteAsUnion::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for SendNotificationBuilder<(T0,)> + impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; - #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for SendNotificationBuilder<(T0,)> + impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; - #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl>> - ::planus::WriteAsOffset for SendNotificationBuilder<(T0,)> + impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - SendNotification::create(builder, v0) + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) } } - /// Reference to a deserialized [SendNotification]. - #[derive(Copy, Clone)] - pub struct SendNotificationRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> SendNotificationRef<'a> { - /// Getter for the [`data` field](SendNotification#structfield.data). + impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn data(&self) -> ::planus::Result<&'a [u8]> { - self.0.access_required(0, "SendNotification", "data") + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl<'a> ::core::fmt::Debug for SendNotificationRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("SendNotificationRef"); - f.field("data", &self.data()); - f.finish() + impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) } } - impl<'a> ::core::convert::TryFrom> for SendNotification { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: SendNotificationRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - data: value.data()?.to_vec(), - }) + impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<3, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + } + } + impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { + #[inline] + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) } } - impl<'a> ::planus::TableRead<'a> for SendNotificationRef<'a> { + impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<4, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl<'a> ::planus::VectorReadInner<'a> for SendNotificationRef<'a> { + /// Reference to a deserialized [TraceInfo]. + #[derive(Copy, Clone, Debug)] + pub enum TraceInfoRef<'a> { + KeyFrameTraceInfo(self::KeyFrameTraceInfoRef<'a>), + FirTraceInfo(self::FirTraceInfoRef<'a>), + PliTraceInfo(self::PliTraceInfoRef<'a>), + RtpTraceInfo(self::RtpTraceInfoRef<'a>), + } + + impl<'a> ::core::convert::TryFrom> for TraceInfo { type Error = ::planus::Error; - const STRIDE: usize = 4; - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[SendNotificationRef]", - "get", - buffer.offset_from_start, - ) - }) - } - } + fn try_from(value: TraceInfoRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + TraceInfoRef::KeyFrameTraceInfo(value) => { + Self::KeyFrameTraceInfo(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } - impl ::planus::VectorWrite<::planus::Offset> for SendNotification { - type Value = ::planus::Offset; - const STRIDE: usize = 4; - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) - } + TraceInfoRef::FirTraceInfo(value) => { + Self::FirTraceInfo(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } - #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); - } + TraceInfoRef::PliTraceInfo(value) => { + Self::PliTraceInfo(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + + TraceInfoRef::RtpTraceInfo(value) => { + Self::RtpTraceInfo(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } + }) } } - impl<'a> ::planus::ReadAsRoot<'a> for SendNotificationRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[SendNotificationRef]", "read_as_root", 0) - }) + impl<'a> ::planus::TableReadUnion<'a> for TraceInfoRef<'a> { + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + field_offset: usize, + tag: u8, + ) -> ::core::result::Result { + match tag { + 1 => ::core::result::Result::Ok(Self::KeyFrameTraceInfo( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::FirTraceInfo( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 3 => ::core::result::Result::Ok(Self::PliTraceInfo( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 4 => ::core::result::Result::Ok(Self::RtpTraceInfo( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), + } } } - /// The table `Score` in the namespace `FBS.Producer` + /// The table `KeyFrameTraceInfo` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `Score` in the file `../worker/fbs/producer.fbs:31` + /// * Table `KeyFrameTraceInfo` in the file `../worker/fbs/producer.fbs:58` #[derive( Clone, Debug, @@ -65869,66 +67885,42 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct Score { - /// The field `ssrc` in the table `Score` - pub ssrc: u32, - /// The field `rid` in the table `Score` - pub rid: ::core::option::Option<::planus::alloc::string::String>, - /// The field `score` in the table `Score` - pub score: u8, + pub struct KeyFrameTraceInfo { + /// The field `is_rtx` in the table `KeyFrameTraceInfo` + pub is_rtx: bool, } #[allow(clippy::derivable_impls)] - impl ::core::default::Default for Score { + impl ::core::default::Default for KeyFrameTraceInfo { fn default() -> Self { - Self { - ssrc: 0, - rid: ::core::default::Default::default(), - score: 0, - } + Self { is_rtx: false } } } - impl Score { - /// Creates a [ScoreBuilder] for serializing an instance of this table. + impl KeyFrameTraceInfo { + /// Creates a [KeyFrameTraceInfoBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ScoreBuilder<()> { - ScoreBuilder(()) + pub fn builder() -> KeyFrameTraceInfoBuilder<()> { + KeyFrameTraceInfoBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ssrc: impl ::planus::WriteAsDefault, - field_rid: impl ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - field_score: impl ::planus::WriteAsDefault, + field_is_rtx: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_ssrc = field_ssrc.prepare(builder, &0); - let prepared_rid = field_rid.prepare(builder); - let prepared_score = field_score.prepare(builder, &0); + let prepared_is_rtx = field_is_rtx.prepare(builder, &false); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_ssrc.is_some() { - table_writer.write_entry::(0); - } - if prepared_rid.is_some() { - table_writer.write_entry::<::planus::Offset>(1); - } - if prepared_score.is_some() { - table_writer.write_entry::(2); + if prepared_is_rtx.is_some() { + table_writer.write_entry::(0); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { - object_writer.write::<_, _, 4>(&prepared_ssrc); - } - if let ::core::option::Option::Some(prepared_rid) = prepared_rid { - object_writer.write::<_, _, 4>(&prepared_rid); - } - if let ::core::option::Option::Some(prepared_score) = prepared_score { - object_writer.write::<_, _, 1>(&prepared_score); + if let ::core::option::Option::Some(prepared_is_rtx) = prepared_is_rtx { + object_writer.write::<_, _, 1>(&prepared_is_rtx); } }); } @@ -65936,213 +67928,161 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for Score { + impl ::planus::WriteAs<::planus::Offset> for KeyFrameTraceInfo { type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for Score { + impl ::planus::WriteAsOptional<::planus::Offset> for KeyFrameTraceInfo { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for Score { + impl ::planus::WriteAsOffset for KeyFrameTraceInfo { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - Score::create(builder, self.ssrc, &self.rid, self.score) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + KeyFrameTraceInfo::create(builder, self.is_rtx) } } - /// Builder for serializing an instance of the [Score] type. + /// Builder for serializing an instance of the [KeyFrameTraceInfo] type. /// - /// Can be created using the [Score::builder] method. + /// Can be created using the [KeyFrameTraceInfo::builder] method. #[derive(Debug)] #[must_use] - pub struct ScoreBuilder(State); - - impl ScoreBuilder<()> { - /// Setter for the [`ssrc` field](Score#structfield.ssrc). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ssrc(self, value: T0) -> ScoreBuilder<(T0,)> - where - T0: ::planus::WriteAsDefault, - { - ScoreBuilder((value,)) - } - - /// Sets the [`ssrc` field](Score#structfield.ssrc) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ssrc_as_default(self) -> ScoreBuilder<(::planus::DefaultValue,)> { - self.ssrc(::planus::DefaultValue) - } - } - - impl ScoreBuilder<(T0,)> { - /// Setter for the [`rid` field](Score#structfield.rid). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rid(self, value: T1) -> ScoreBuilder<(T0, T1)> - where - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - { - let (v0,) = self.0; - ScoreBuilder((v0, value)) - } - - /// Sets the [`rid` field](Score#structfield.rid) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rid_as_null(self) -> ScoreBuilder<(T0, ())> { - self.rid(()) - } - } + pub struct KeyFrameTraceInfoBuilder(State); - impl ScoreBuilder<(T0, T1)> { - /// Setter for the [`score` field](Score#structfield.score). + impl KeyFrameTraceInfoBuilder<()> { + /// Setter for the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx). #[inline] #[allow(clippy::type_complexity)] - pub fn score(self, value: T2) -> ScoreBuilder<(T0, T1, T2)> + pub fn is_rtx(self, value: T0) -> KeyFrameTraceInfoBuilder<(T0,)> where - T2: ::planus::WriteAsDefault, + T0: ::planus::WriteAsDefault, { - let (v0, v1) = self.0; - ScoreBuilder((v0, v1, value)) + KeyFrameTraceInfoBuilder((value,)) } - /// Sets the [`score` field](Score#structfield.score) to the default value. + /// Sets the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn score_as_default(self) -> ScoreBuilder<(T0, T1, ::planus::DefaultValue)> { - self.score(::planus::DefaultValue) + pub fn is_rtx_as_default( + self, + ) -> KeyFrameTraceInfoBuilder<(::planus::DefaultValue,)> { + self.is_rtx(::planus::DefaultValue) } } - impl ScoreBuilder<(T0, T1, T2)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Score]. + impl KeyFrameTraceInfoBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [KeyFrameTraceInfo]. #[inline] - pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> for ScoreBuilder<(T0, T1, T2)> + impl> + ::planus::WriteAs<::planus::Offset> + for KeyFrameTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> - for ScoreBuilder<(T0, T1, T2)> + impl> + ::planus::WriteAsOptional<::planus::Offset> + for KeyFrameTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset for ScoreBuilder<(T0, T1, T2)> + impl> + ::planus::WriteAsOffset for KeyFrameTraceInfoBuilder<(T0,)> { #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - Score::create(builder, v0, v1, v2) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + KeyFrameTraceInfo::create(builder, v0) } } - /// Reference to a deserialized [Score]. + /// Reference to a deserialized [KeyFrameTraceInfo]. #[derive(Copy, Clone)] - pub struct ScoreRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> ScoreRef<'a> { - /// Getter for the [`ssrc` field](Score#structfield.ssrc). - #[inline] - pub fn ssrc(&self) -> ::planus::Result { - ::core::result::Result::Ok(self.0.access(0, "Score", "ssrc")?.unwrap_or(0)) - } - - /// Getter for the [`rid` field](Score#structfield.rid). - #[inline] - pub fn rid( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(1, "Score", "rid") - } + pub struct KeyFrameTraceInfoRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`score` field](Score#structfield.score). + impl<'a> KeyFrameTraceInfoRef<'a> { + /// Getter for the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx). #[inline] - pub fn score(&self) -> ::planus::Result { - ::core::result::Result::Ok(self.0.access(2, "Score", "score")?.unwrap_or(0)) + pub fn is_rtx(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "KeyFrameTraceInfo", "is_rtx")? + .unwrap_or(false), + ) } } - impl<'a> ::core::fmt::Debug for ScoreRef<'a> { + impl<'a> ::core::fmt::Debug for KeyFrameTraceInfoRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ScoreRef"); - f.field("ssrc", &self.ssrc()); - if let ::core::option::Option::Some(field_rid) = self.rid().transpose() { - f.field("rid", &field_rid); - } - f.field("score", &self.score()); + let mut f = f.debug_struct("KeyFrameTraceInfoRef"); + f.field("is_rtx", &self.is_rtx()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for Score { + impl<'a> ::core::convert::TryFrom> for KeyFrameTraceInfo { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ScoreRef<'a>) -> ::planus::Result { + fn try_from(value: KeyFrameTraceInfoRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, - rid: if let ::core::option::Option::Some(rid) = value.rid()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(rid)?) - } else { - ::core::option::Option::None - }, - score: ::core::convert::TryInto::try_into(value.score()?)?, + is_rtx: ::core::convert::TryInto::try_into(value.is_rtx()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for ScoreRef<'a> { + impl<'a> ::planus::TableRead<'a> for KeyFrameTraceInfoRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -66154,7 +68094,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ScoreRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for KeyFrameTraceInfoRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -66164,7 +68104,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ScoreRef]", + "[KeyFrameTraceInfoRef]", "get", buffer.offset_from_start, ) @@ -66172,8 +68112,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for Score { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for KeyFrameTraceInfo { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -66182,7 +68122,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -66197,7 +68137,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ScoreRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for KeyFrameTraceInfoRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -66207,15 +68147,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[ScoreRef]", "read_as_root", 0) + error_kind.with_error_location("[KeyFrameTraceInfoRef]", "read_as_root", 0) }) } } - /// The table `ScoreNotification` in the namespace `FBS.Producer` + /// The table `FirTraceInfo` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `ScoreNotification` in the file `../worker/fbs/producer.fbs:37` + /// * Table `FirTraceInfo` in the file `../worker/fbs/producer.fbs:62` #[derive( Clone, Debug, @@ -66227,47 +68167,42 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct ScoreNotification { - /// The field `scores` in the table `ScoreNotification` - pub scores: ::core::option::Option<::planus::alloc::vec::Vec>, + pub struct FirTraceInfo { + /// The field `ssrc` in the table `FirTraceInfo` + pub ssrc: u32, } #[allow(clippy::derivable_impls)] - impl ::core::default::Default for ScoreNotification { + impl ::core::default::Default for FirTraceInfo { fn default() -> Self { - Self { - scores: ::core::default::Default::default(), - } + Self { ssrc: 0 } } } - impl ScoreNotification { - /// Creates a [ScoreNotificationBuilder] for serializing an instance of this table. + impl FirTraceInfo { + /// Creates a [FirTraceInfoBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ScoreNotificationBuilder<()> { - ScoreNotificationBuilder(()) + pub fn builder() -> FirTraceInfoBuilder<()> { + FirTraceInfoBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_scores: impl ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, + field_ssrc: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_scores = field_scores.prepare(builder); + let prepared_ssrc = field_ssrc.prepare(builder, &0); let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_scores.is_some() { - table_writer - .write_entry::<::planus::Offset<[::planus::Offset]>>(0); + if prepared_ssrc.is_some() { + table_writer.write_entry::(0); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_scores) = prepared_scores { - object_writer.write::<_, _, 4>(&prepared_scores); + if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { + object_writer.write::<_, _, 4>(&prepared_ssrc); } }); } @@ -66275,172 +68210,156 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for ScoreNotification { + impl ::planus::WriteAs<::planus::Offset> for FirTraceInfo { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for ScoreNotification { + impl ::planus::WriteAsOptional<::planus::Offset> for FirTraceInfo { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for ScoreNotification { + impl ::planus::WriteAsOffset for FirTraceInfo { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ScoreNotification::create(builder, &self.scores) + ) -> ::planus::Offset { + FirTraceInfo::create(builder, self.ssrc) } } - /// Builder for serializing an instance of the [ScoreNotification] type. + /// Builder for serializing an instance of the [FirTraceInfo] type. /// - /// Can be created using the [ScoreNotification::builder] method. + /// Can be created using the [FirTraceInfo::builder] method. #[derive(Debug)] #[must_use] - pub struct ScoreNotificationBuilder(State); + pub struct FirTraceInfoBuilder(State); - impl ScoreNotificationBuilder<()> { - /// Setter for the [`scores` field](ScoreNotification#structfield.scores). + impl FirTraceInfoBuilder<()> { + /// Setter for the [`ssrc` field](FirTraceInfo#structfield.ssrc). #[inline] #[allow(clippy::type_complexity)] - pub fn scores(self, value: T0) -> ScoreNotificationBuilder<(T0,)> + pub fn ssrc(self, value: T0) -> FirTraceInfoBuilder<(T0,)> where - T0: ::planus::WriteAsOptional< - ::planus::Offset<[::planus::Offset]>, - >, + T0: ::planus::WriteAsDefault, { - ScoreNotificationBuilder((value,)) + FirTraceInfoBuilder((value,)) } - /// Sets the [`scores` field](ScoreNotification#structfield.scores) to null. + /// Sets the [`ssrc` field](FirTraceInfo#structfield.ssrc) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn scores_as_null(self) -> ScoreNotificationBuilder<((),)> { - self.scores(()) + pub fn ssrc_as_default(self) -> FirTraceInfoBuilder<(::planus::DefaultValue,)> { + self.ssrc(::planus::DefaultValue) } } - impl ScoreNotificationBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ScoreNotification]. + impl FirTraceInfoBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [FirTraceInfo]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAs<::planus::Offset> - for ScoreNotificationBuilder<(T0,)> + impl> + ::planus::WriteAs<::planus::Offset> for FirTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOptional<::planus::Offset> - for ScoreNotificationBuilder<(T0,)> + impl> + ::planus::WriteAsOptional<::planus::Offset> + for FirTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<[::planus::Offset]>>, - > ::planus::WriteAsOffset for ScoreNotificationBuilder<(T0,)> + impl> ::planus::WriteAsOffset + for FirTraceInfoBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0,) = &self.0; - ScoreNotification::create(builder, v0) + FirTraceInfo::create(builder, v0) } } - /// Reference to a deserialized [ScoreNotification]. + /// Reference to a deserialized [FirTraceInfo]. #[derive(Copy, Clone)] - pub struct ScoreNotificationRef<'a>(::planus::table_reader::Table<'a>); + pub struct FirTraceInfoRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> ScoreNotificationRef<'a> { - /// Getter for the [`scores` field](ScoreNotification#structfield.scores). + impl<'a> FirTraceInfoRef<'a> { + /// Getter for the [`ssrc` field](FirTraceInfo#structfield.ssrc). #[inline] - pub fn scores( - &self, - ) -> ::planus::Result< - ::core::option::Option< - ::planus::Vector<'a, ::planus::Result>>, - >, - > { - self.0.access(0, "ScoreNotification", "scores") + pub fn ssrc(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0.access(0, "FirTraceInfo", "ssrc")?.unwrap_or(0), + ) } } - impl<'a> ::core::fmt::Debug for ScoreNotificationRef<'a> { + impl<'a> ::core::fmt::Debug for FirTraceInfoRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ScoreNotificationRef"); - if let ::core::option::Option::Some(field_scores) = self.scores().transpose() { - f.field("scores", &field_scores); - } + let mut f = f.debug_struct("FirTraceInfoRef"); + f.field("ssrc", &self.ssrc()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ScoreNotification { + impl<'a> ::core::convert::TryFrom> for FirTraceInfo { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ScoreNotificationRef<'a>) -> ::planus::Result { + fn try_from(value: FirTraceInfoRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - scores: if let ::core::option::Option::Some(scores) = value.scores()? { - ::core::option::Option::Some(scores.to_vec_result()?) - } else { - ::core::option::Option::None - }, + ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for ScoreNotificationRef<'a> { + impl<'a> ::planus::TableRead<'a> for FirTraceInfoRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -66452,7 +68371,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ScoreNotificationRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for FirTraceInfoRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -66462,7 +68381,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ScoreNotificationRef]", + "[FirTraceInfoRef]", "get", buffer.offset_from_start, ) @@ -66470,8 +68389,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ScoreNotification { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for FirTraceInfo { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -66480,7 +68399,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -66495,7 +68414,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ScoreNotificationRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for FirTraceInfoRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -66505,15 +68424,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[ScoreNotificationRef]", "read_as_root", 0) + error_kind.with_error_location("[FirTraceInfoRef]", "read_as_root", 0) }) } } - /// The table `VideoOrientationChangeNotification` in the namespace `FBS.Producer` + /// The table `PliTraceInfo` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Table `VideoOrientationChangeNotification` in the file `../worker/fbs/producer.fbs:41` + /// * Table `PliTraceInfo` in the file `../worker/fbs/producer.fbs:66` #[derive( Clone, Debug, @@ -66525,68 +68444,42 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct VideoOrientationChangeNotification { - /// The field `camera` in the table `VideoOrientationChangeNotification` - pub camera: bool, - /// The field `flip` in the table `VideoOrientationChangeNotification` - pub flip: bool, - /// The field `rotation` in the table `VideoOrientationChangeNotification` - pub rotation: u16, + pub struct PliTraceInfo { + /// The field `ssrc` in the table `PliTraceInfo` + pub ssrc: u32, } #[allow(clippy::derivable_impls)] - impl ::core::default::Default for VideoOrientationChangeNotification { + impl ::core::default::Default for PliTraceInfo { fn default() -> Self { - Self { - camera: false, - flip: false, - rotation: 0, - } + Self { ssrc: 0 } } } - impl VideoOrientationChangeNotification { - /// Creates a [VideoOrientationChangeNotificationBuilder] for serializing an instance of this table. + impl PliTraceInfo { + /// Creates a [PliTraceInfoBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> VideoOrientationChangeNotificationBuilder<()> { - VideoOrientationChangeNotificationBuilder(()) + pub fn builder() -> PliTraceInfoBuilder<()> { + PliTraceInfoBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_camera: impl ::planus::WriteAsDefault, - field_flip: impl ::planus::WriteAsDefault, - field_rotation: impl ::planus::WriteAsDefault, + field_ssrc: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_camera = field_camera.prepare(builder, &false); - let prepared_flip = field_flip.prepare(builder, &false); - let prepared_rotation = field_rotation.prepare(builder, &0); + let prepared_ssrc = field_ssrc.prepare(builder, &0); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_rotation.is_some() { - table_writer.write_entry::(2); - } - if prepared_camera.is_some() { - table_writer.write_entry::(0); - } - if prepared_flip.is_some() { - table_writer.write_entry::(1); + if prepared_ssrc.is_some() { + table_writer.write_entry::(0); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_rotation) = - prepared_rotation - { - object_writer.write::<_, _, 2>(&prepared_rotation); - } - if let ::core::option::Option::Some(prepared_camera) = prepared_camera { - object_writer.write::<_, _, 1>(&prepared_camera); - } - if let ::core::option::Option::Some(prepared_flip) = prepared_flip { - object_writer.write::<_, _, 1>(&prepared_flip); + if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { + object_writer.write::<_, _, 4>(&prepared_ssrc); } }); } @@ -66594,270 +68487,156 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> - for VideoOrientationChangeNotification - { + impl ::planus::WriteAs<::planus::Offset> for PliTraceInfo { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for VideoOrientationChangeNotification - { + impl ::planus::WriteAsOptional<::planus::Offset> for PliTraceInfo { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset - for VideoOrientationChangeNotification - { + impl ::planus::WriteAsOffset for PliTraceInfo { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - VideoOrientationChangeNotification::create( - builder, - self.camera, - self.flip, - self.rotation, - ) + ) -> ::planus::Offset { + PliTraceInfo::create(builder, self.ssrc) } } - /// Builder for serializing an instance of the [VideoOrientationChangeNotification] type. + /// Builder for serializing an instance of the [PliTraceInfo] type. /// - /// Can be created using the [VideoOrientationChangeNotification::builder] method. + /// Can be created using the [PliTraceInfo::builder] method. #[derive(Debug)] #[must_use] - pub struct VideoOrientationChangeNotificationBuilder(State); - - impl VideoOrientationChangeNotificationBuilder<()> { - /// Setter for the [`camera` field](VideoOrientationChangeNotification#structfield.camera). - #[inline] - #[allow(clippy::type_complexity)] - pub fn camera( - self, - value: T0, - ) -> VideoOrientationChangeNotificationBuilder<(T0,)> - where - T0: ::planus::WriteAsDefault, - { - VideoOrientationChangeNotificationBuilder((value,)) - } - - /// Sets the [`camera` field](VideoOrientationChangeNotification#structfield.camera) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn camera_as_default( - self, - ) -> VideoOrientationChangeNotificationBuilder<(::planus::DefaultValue,)> - { - self.camera(::planus::DefaultValue) - } - } - - impl VideoOrientationChangeNotificationBuilder<(T0,)> { - /// Setter for the [`flip` field](VideoOrientationChangeNotification#structfield.flip). - #[inline] - #[allow(clippy::type_complexity)] - pub fn flip( - self, - value: T1, - ) -> VideoOrientationChangeNotificationBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault, - { - let (v0,) = self.0; - VideoOrientationChangeNotificationBuilder((v0, value)) - } - - /// Sets the [`flip` field](VideoOrientationChangeNotification#structfield.flip) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn flip_as_default( - self, - ) -> VideoOrientationChangeNotificationBuilder<(T0, ::planus::DefaultValue)> - { - self.flip(::planus::DefaultValue) - } - } + pub struct PliTraceInfoBuilder(State); - impl VideoOrientationChangeNotificationBuilder<(T0, T1)> { - /// Setter for the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation). + impl PliTraceInfoBuilder<()> { + /// Setter for the [`ssrc` field](PliTraceInfo#structfield.ssrc). #[inline] #[allow(clippy::type_complexity)] - pub fn rotation( - self, - value: T2, - ) -> VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> + pub fn ssrc(self, value: T0) -> PliTraceInfoBuilder<(T0,)> where - T2: ::planus::WriteAsDefault, + T0: ::planus::WriteAsDefault, { - let (v0, v1) = self.0; - VideoOrientationChangeNotificationBuilder((v0, v1, value)) + PliTraceInfoBuilder((value,)) } - /// Sets the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation) to the default value. + /// Sets the [`ssrc` field](PliTraceInfo#structfield.ssrc) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn rotation_as_default( - self, - ) -> VideoOrientationChangeNotificationBuilder<(T0, T1, ::planus::DefaultValue)> - { - self.rotation(::planus::DefaultValue) + pub fn ssrc_as_default(self) -> PliTraceInfoBuilder<(::planus::DefaultValue,)> { + self.ssrc(::planus::DefaultValue) } } - impl VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [VideoOrientationChangeNotification]. + impl PliTraceInfoBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PliTraceInfo]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - > - ::planus::WriteAs<::planus::Offset> - for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> + impl> + ::planus::WriteAs<::planus::Offset> for PliTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - > - ::planus::WriteAsOptional<::planus::Offset> - for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> + impl> + ::planus::WriteAsOptional<::planus::Offset> + for PliTraceInfoBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset - for VideoOrientationChangeNotificationBuilder<(T0, T1, T2)> + impl> ::planus::WriteAsOffset + for PliTraceInfoBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - VideoOrientationChangeNotification::create(builder, v0, v1, v2) + ) -> ::planus::Offset { + let (v0,) = &self.0; + PliTraceInfo::create(builder, v0) } } - /// Reference to a deserialized [VideoOrientationChangeNotification]. + /// Reference to a deserialized [PliTraceInfo]. #[derive(Copy, Clone)] - pub struct VideoOrientationChangeNotificationRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> VideoOrientationChangeNotificationRef<'a> { - /// Getter for the [`camera` field](VideoOrientationChangeNotification#structfield.camera). - #[inline] - pub fn camera(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(0, "VideoOrientationChangeNotification", "camera")? - .unwrap_or(false), - ) - } - - /// Getter for the [`flip` field](VideoOrientationChangeNotification#structfield.flip). - #[inline] - pub fn flip(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "VideoOrientationChangeNotification", "flip")? - .unwrap_or(false), - ) - } + pub struct PliTraceInfoRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`rotation` field](VideoOrientationChangeNotification#structfield.rotation). + impl<'a> PliTraceInfoRef<'a> { + /// Getter for the [`ssrc` field](PliTraceInfo#structfield.ssrc). #[inline] - pub fn rotation(&self) -> ::planus::Result { + pub fn ssrc(&self) -> ::planus::Result { ::core::result::Result::Ok( - self.0 - .access(2, "VideoOrientationChangeNotification", "rotation")? - .unwrap_or(0), + self.0.access(0, "PliTraceInfo", "ssrc")?.unwrap_or(0), ) } } - impl<'a> ::core::fmt::Debug for VideoOrientationChangeNotificationRef<'a> { + impl<'a> ::core::fmt::Debug for PliTraceInfoRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("VideoOrientationChangeNotificationRef"); - f.field("camera", &self.camera()); - f.field("flip", &self.flip()); - f.field("rotation", &self.rotation()); + let mut f = f.debug_struct("PliTraceInfoRef"); + f.field("ssrc", &self.ssrc()); f.finish() } } - impl<'a> ::core::convert::TryFrom> - for VideoOrientationChangeNotification - { + impl<'a> ::core::convert::TryFrom> for PliTraceInfo { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from( - value: VideoOrientationChangeNotificationRef<'a>, - ) -> ::planus::Result { + fn try_from(value: PliTraceInfoRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - camera: ::core::convert::TryInto::try_into(value.camera()?)?, - flip: ::core::convert::TryInto::try_into(value.flip()?)?, - rotation: ::core::convert::TryInto::try_into(value.rotation()?)?, + ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for VideoOrientationChangeNotificationRef<'a> { + impl<'a> ::planus::TableRead<'a> for PliTraceInfoRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -66869,7 +68648,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for VideoOrientationChangeNotificationRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for PliTraceInfoRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -66879,7 +68658,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[VideoOrientationChangeNotificationRef]", + "[PliTraceInfoRef]", "get", buffer.offset_from_start, ) @@ -66887,10 +68666,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> - for VideoOrientationChangeNotification - { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for PliTraceInfo { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -66899,7 +68676,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -66914,7 +68691,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for VideoOrientationChangeNotificationRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for PliTraceInfoRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -66924,372 +68701,292 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[VideoOrientationChangeNotificationRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[PliTraceInfoRef]", "read_as_root", 0) }) } } - /// The enum `TraceType` in the namespace `FBS.Producer` + /// The table `RtpTraceInfo` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Enum `TraceType` in the file `../worker/fbs/producer.fbs:47` + /// * Table `RtpTraceInfo` in the file `../worker/fbs/producer.fbs:70` #[derive( - Copy, Clone, Debug, PartialEq, - Eq, PartialOrd, + Eq, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - #[repr(u8)] - pub enum TraceType { - /// The variant `KEYFRAME` in the enum `TraceType` - Keyframe = 0, - - /// The variant `FIR` in the enum `TraceType` - Fir = 1, - - /// The variant `NACK` in the enum `TraceType` - Nack = 2, - - /// The variant `PLI` in the enum `TraceType` - Pli = 3, - - /// The variant `RTP` in the enum `TraceType` - Rtp = 4, - } - - impl TraceType { - /// Array containing all valid variants of TraceType - pub const ENUM_VALUES: [Self; 5] = - [Self::Keyframe, Self::Fir, Self::Nack, Self::Pli, Self::Rtp]; + pub struct RtpTraceInfo { + /// The field `is_rtx` in the table `RtpTraceInfo` + pub is_rtx: bool, } - impl ::core::convert::TryFrom for TraceType { - type Error = ::planus::errors::UnknownEnumTagKind; - #[inline] - fn try_from( - value: u8, - ) -> ::core::result::Result - { - #[allow(clippy::match_single_binding)] - match value { - 0 => ::core::result::Result::Ok(TraceType::Keyframe), - 1 => ::core::result::Result::Ok(TraceType::Fir), - 2 => ::core::result::Result::Ok(TraceType::Nack), - 3 => ::core::result::Result::Ok(TraceType::Pli), - 4 => ::core::result::Result::Ok(TraceType::Rtp), - - _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { - tag: value as i128, - }), - } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for RtpTraceInfo { + fn default() -> Self { + Self { is_rtx: false } } } - impl ::core::convert::From for u8 { + impl RtpTraceInfo { + /// Creates a [RtpTraceInfoBuilder] for serializing an instance of this table. #[inline] - fn from(value: TraceType) -> Self { - value as u8 + pub fn builder() -> RtpTraceInfoBuilder<()> { + RtpTraceInfoBuilder(()) } - } - - impl ::planus::Primitive for TraceType { - const ALIGNMENT: usize = 1; - const SIZE: usize = 1; - } - impl ::planus::WriteAsPrimitive for TraceType { - #[inline] - fn write( - &self, - cursor: ::planus::Cursor<'_, N>, - buffer_position: u32, - ) { - (*self as u8).write(cursor, buffer_position); - } - } + #[allow(clippy::too_many_arguments)] + pub fn create( + builder: &mut ::planus::Builder, + field_is_rtx: impl ::planus::WriteAsDefault, + ) -> ::planus::Offset { + let prepared_is_rtx = field_is_rtx.prepare(builder, &false); - impl ::planus::WriteAs for TraceType { - type Prepared = Self; + let mut table_writer: ::planus::table_writer::TableWriter<6> = + ::core::default::Default::default(); + if prepared_is_rtx.is_some() { + table_writer.write_entry::(0); + } - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> TraceType { - *self + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_is_rtx) = prepared_is_rtx { + object_writer.write::<_, _, 1>(&prepared_is_rtx); + } + }); + } + builder.current_offset() } } - impl ::planus::WriteAsDefault for TraceType { - type Prepared = Self; + impl ::planus::WriteAs<::planus::Offset> for RtpTraceInfo { + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, - _builder: &mut ::planus::Builder, - default: &TraceType, - ) -> ::core::option::Option { - if self == default { - ::core::option::Option::None - } else { - ::core::option::Option::Some(*self) - } + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional for TraceType { - type Prepared = Self; + impl ::planus::WriteAsOptional<::planus::Offset> for RtpTraceInfo { + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, - _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { - ::core::option::Option::Some(*self) - } - } - - impl<'buf> ::planus::TableRead<'buf> for TraceType { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result { - let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; - ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) - } - } - - impl<'buf> ::planus::VectorReadInner<'buf> for TraceType { - type Error = ::planus::errors::UnknownEnumTag; - const STRIDE: usize = 1; - #[inline] - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result - { - let value = *buffer.buffer.get_unchecked(offset); - let value: ::core::result::Result = - ::core::convert::TryInto::try_into(value); - value.map_err(|error_kind| { - error_kind.with_error_location( - "TraceType", - "VectorRead::from_buffer", - buffer.offset_from_start, - ) - }) + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::VectorWrite for TraceType { - const STRIDE: usize = 1; - - type Value = Self; - - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { - *self - } - + impl ::planus::WriteAsOffset for RtpTraceInfo { #[inline] - unsafe fn write_values( - values: &[Self], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - i as u32, - ); - } + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + RtpTraceInfo::create(builder, self.is_rtx) } } - /// The enum `TraceDirection` in the namespace `FBS.Producer` + /// Builder for serializing an instance of the [RtpTraceInfo] type. /// - /// Generated from these locations: - /// * Enum `TraceDirection` in the file `../worker/fbs/producer.fbs:49` - #[derive( - Copy, - Clone, - Debug, - PartialEq, - Eq, - PartialOrd, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - #[repr(u8)] - pub enum TraceDirection { - /// The variant `DIRECTION_IN` in the enum `TraceDirection` - DirectionIn = 0, - - /// The variant `DIRECTION_OUT` in the enum `TraceDirection` - DirectionOut = 1, - } - - impl TraceDirection { - /// Array containing all valid variants of TraceDirection - pub const ENUM_VALUES: [Self; 2] = [Self::DirectionIn, Self::DirectionOut]; - } + /// Can be created using the [RtpTraceInfo::builder] method. + #[derive(Debug)] + #[must_use] + pub struct RtpTraceInfoBuilder(State); - impl ::core::convert::TryFrom for TraceDirection { - type Error = ::planus::errors::UnknownEnumTagKind; + impl RtpTraceInfoBuilder<()> { + /// Setter for the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx). #[inline] - fn try_from( - value: u8, - ) -> ::core::result::Result + #[allow(clippy::type_complexity)] + pub fn is_rtx(self, value: T0) -> RtpTraceInfoBuilder<(T0,)> + where + T0: ::planus::WriteAsDefault, { - #[allow(clippy::match_single_binding)] - match value { - 0 => ::core::result::Result::Ok(TraceDirection::DirectionIn), - 1 => ::core::result::Result::Ok(TraceDirection::DirectionOut), + RtpTraceInfoBuilder((value,)) + } - _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { - tag: value as i128, - }), - } + /// Sets the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn is_rtx_as_default(self) -> RtpTraceInfoBuilder<(::planus::DefaultValue,)> { + self.is_rtx(::planus::DefaultValue) } } - impl ::core::convert::From for u8 { + impl RtpTraceInfoBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [RtpTraceInfo]. #[inline] - fn from(value: TraceDirection) -> Self { - value as u8 + pub fn finish( + self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset + where + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::Primitive for TraceDirection { - const ALIGNMENT: usize = 1; - const SIZE: usize = 1; - } + impl> + ::planus::WriteAs<::planus::Offset> for RtpTraceInfoBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - impl ::planus::WriteAsPrimitive for TraceDirection { #[inline] - fn write( + fn prepare( &self, - cursor: ::planus::Cursor<'_, N>, - buffer_position: u32, - ) { - (*self as u8).write(cursor, buffer_position); + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAs for TraceDirection { - type Prepared = Self; + impl> + ::planus::WriteAsOptional<::planus::Offset> + for RtpTraceInfoBuilder<(T0,)> + { + type Prepared = ::planus::Offset; #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> TraceDirection { - *self + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsDefault for TraceDirection { - type Prepared = Self; - + impl> ::planus::WriteAsOffset + for RtpTraceInfoBuilder<(T0,)> + { #[inline] fn prepare( &self, - _builder: &mut ::planus::Builder, - default: &TraceDirection, - ) -> ::core::option::Option { - if self == default { - ::core::option::Option::None - } else { - ::core::option::Option::Some(*self) - } + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + RtpTraceInfo::create(builder, v0) } } - impl ::planus::WriteAsOptional for TraceDirection { - type Prepared = Self; + /// Reference to a deserialized [RtpTraceInfo]. + #[derive(Copy, Clone)] + pub struct RtpTraceInfoRef<'a>(::planus::table_reader::Table<'a>); + impl<'a> RtpTraceInfoRef<'a> { + /// Getter for the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx). #[inline] - fn prepare( - &self, - _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { - ::core::option::Option::Some(*self) + pub fn is_rtx(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0.access(0, "RtpTraceInfo", "is_rtx")?.unwrap_or(false), + ) } } - impl<'buf> ::planus::TableRead<'buf> for TraceDirection { + impl<'a> ::core::fmt::Debug for RtpTraceInfoRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("RtpTraceInfoRef"); + f.field("is_rtx", &self.is_rtx()); + f.finish() + } + } + + impl<'a> ::core::convert::TryFrom> for RtpTraceInfo { + type Error = ::planus::Error; + + #[allow(unreachable_code)] + fn try_from(value: RtpTraceInfoRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + is_rtx: ::core::convert::TryInto::try_into(value.is_rtx()?)?, + }) + } + } + + impl<'a> ::planus::TableRead<'a> for RtpTraceInfoRef<'a> { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, + buffer: ::planus::SliceWithStartOffset<'a>, offset: usize, ) -> ::core::result::Result { - let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; - ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) } } - impl<'buf> ::planus::VectorReadInner<'buf> for TraceDirection { - type Error = ::planus::errors::UnknownEnumTag; - const STRIDE: usize = 1; - #[inline] + impl<'a> ::planus::VectorReadInner<'a> for RtpTraceInfoRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, + buffer: ::planus::SliceWithStartOffset<'a>, offset: usize, - ) -> ::core::result::Result - { - let value = *buffer.buffer.get_unchecked(offset); - let value: ::core::result::Result = - ::core::convert::TryInto::try_into(value); - value.map_err(|error_kind| { + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "TraceDirection", - "VectorRead::from_buffer", + "[RtpTraceInfoRef]", + "get", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite for TraceDirection { - const STRIDE: usize = 1; - - type Value = Self; - + impl ::planus::VectorWrite<::planus::Offset> for RtpTraceInfo { + type Value = ::planus::Offset; + const STRIDE: usize = 4; #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { - *self + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) } #[inline] unsafe fn write_values( - values: &[Self], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - i as u32, + buffer_position - (Self::STRIDE * i) as u32, ); } } } - /// The union `TraceInfo` in the namespace `FBS.Producer` + impl<'a> ::planus::ReadAsRoot<'a> for RtpTraceInfoRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[RtpTraceInfoRef]", "read_as_root", 0) + }) + } + } + + /// The table `TraceNotification` in the namespace `FBS.Producer` /// /// Generated from these locations: - /// * Union `TraceInfo` in the file `../worker/fbs/producer.fbs:51` + /// * Table `TraceNotification` in the file `../worker/fbs/producer.fbs:74` #[derive( Clone, Debug, @@ -67301,327 +68998,455 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub enum TraceInfo { - /// The variant of type `KeyFrameTraceInfo` in the union `TraceInfo` - KeyFrameTraceInfo(::planus::alloc::boxed::Box), - - /// The variant of type `FirTraceInfo` in the union `TraceInfo` - FirTraceInfo(::planus::alloc::boxed::Box), - - /// The variant of type `PliTraceInfo` in the union `TraceInfo` - PliTraceInfo(::planus::alloc::boxed::Box), - - /// The variant of type `RtpTraceInfo` in the union `TraceInfo` - RtpTraceInfo(::planus::alloc::boxed::Box), + pub struct TraceNotification { + /// The field `type` in the table `TraceNotification` + pub type_: self::TraceType, + /// The field `timestamp` in the table `TraceNotification` + pub timestamp: u64, + /// The field `direction` in the table `TraceNotification` + pub direction: self::TraceDirection, + /// The field `info` in the table `TraceNotification` + pub info: ::core::option::Option, } - impl TraceInfo { - /// Creates a [TraceInfoBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> TraceInfoBuilder<::planus::Uninitialized> { - TraceInfoBuilder(::planus::Uninitialized) + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for TraceNotification { + fn default() -> Self { + Self { + type_: self::TraceType::Keyframe, + timestamp: 0, + direction: self::TraceDirection::DirectionIn, + info: ::core::default::Default::default(), + } } + } + impl TraceNotification { + /// Creates a [TraceNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn create_key_frame_trace_info( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) + pub fn builder() -> TraceNotificationBuilder<()> { + TraceNotificationBuilder(()) } - #[inline] - pub fn create_fir_trace_info( + #[allow(clippy::too_many_arguments)] + pub fn create( builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) - } + field_type_: impl ::planus::WriteAsDefault, + field_timestamp: impl ::planus::WriteAsDefault, + field_direction: impl ::planus::WriteAsDefault< + self::TraceDirection, + self::TraceDirection, + >, + field_info: impl ::planus::WriteAsOptionalUnion, + ) -> ::planus::Offset { + let prepared_type_ = field_type_.prepare(builder, &self::TraceType::Keyframe); + let prepared_timestamp = field_timestamp.prepare(builder, &0); + let prepared_direction = + field_direction.prepare(builder, &self::TraceDirection::DirectionIn); + let prepared_info = field_info.prepare(builder); - #[inline] - pub fn create_pli_trace_info( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, value.prepare(builder).downcast()) + let mut table_writer: ::planus::table_writer::TableWriter<14> = + ::core::default::Default::default(); + if prepared_timestamp.is_some() { + table_writer.write_entry::(1); + } + if prepared_info.is_some() { + table_writer.write_entry::<::planus::Offset>(4); + } + if prepared_type_.is_some() { + table_writer.write_entry::(0); + } + if prepared_direction.is_some() { + table_writer.write_entry::(2); + } + if prepared_info.is_some() { + table_writer.write_entry::(3); + } + + unsafe { + table_writer.finish(builder, |object_writer| { + if let ::core::option::Option::Some(prepared_timestamp) = + prepared_timestamp + { + object_writer.write::<_, _, 8>(&prepared_timestamp); + } + if let ::core::option::Option::Some(prepared_info) = prepared_info { + object_writer.write::<_, _, 4>(&prepared_info.offset()); + } + if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { + object_writer.write::<_, _, 1>(&prepared_type_); + } + if let ::core::option::Option::Some(prepared_direction) = + prepared_direction + { + object_writer.write::<_, _, 1>(&prepared_direction); + } + if let ::core::option::Option::Some(prepared_info) = prepared_info { + object_writer.write::<_, _, 1>(&prepared_info.tag()); + } + }); + } + builder.current_offset() } + } + + impl ::planus::WriteAs<::planus::Offset> for TraceNotification { + type Prepared = ::planus::Offset; #[inline] - pub fn create_rtp_trace_info( + fn prepare( + &self, builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, value.prepare(builder).downcast()) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsUnion for TraceInfo { + impl ::planus::WriteAsOptional<::planus::Offset> for TraceNotification { + type Prepared = ::planus::Offset; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - match self { - Self::KeyFrameTraceInfo(value) => { - Self::create_key_frame_trace_info(builder, value) - } - Self::FirTraceInfo(value) => Self::create_fir_trace_info(builder, value), - Self::PliTraceInfo(value) => Self::create_pli_trace_info(builder, value), - Self::RtpTraceInfo(value) => Self::create_rtp_trace_info(builder, value), - } + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for TraceInfo { + impl ::planus::WriteAsOffset for TraceNotification { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + TraceNotification::create( + builder, + self.type_, + self.timestamp, + self.direction, + &self.info, + ) } } - /// Builder for serializing an instance of the [TraceInfo] type. + /// Builder for serializing an instance of the [TraceNotification] type. /// - /// Can be created using the [TraceInfo::builder] method. + /// Can be created using the [TraceNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct TraceInfoBuilder(T); + pub struct TraceNotificationBuilder(State); - impl TraceInfoBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`KeyFrameTraceInfo` variant](TraceInfo#variant.KeyFrameTraceInfo). + impl TraceNotificationBuilder<()> { + /// Setter for the [`type` field](TraceNotification#structfield.type_). #[inline] - pub fn key_frame_trace_info( - self, - value: T, - ) -> TraceInfoBuilder<::planus::Initialized<1, T>> + #[allow(clippy::type_complexity)] + pub fn type_(self, value: T0) -> TraceNotificationBuilder<(T0,)> where - T: ::planus::WriteAsOffset, + T0: ::planus::WriteAsDefault, { - TraceInfoBuilder(::planus::Initialized(value)) + TraceNotificationBuilder((value,)) } - /// Creates an instance of the [`FirTraceInfo` variant](TraceInfo#variant.FirTraceInfo). + /// Sets the [`type` field](TraceNotification#structfield.type_) to the default value. #[inline] - pub fn fir_trace_info( + #[allow(clippy::type_complexity)] + pub fn type_as_default( self, - value: T, - ) -> TraceInfoBuilder<::planus::Initialized<2, T>> + ) -> TraceNotificationBuilder<(::planus::DefaultValue,)> { + self.type_(::planus::DefaultValue) + } + } + + impl TraceNotificationBuilder<(T0,)> { + /// Setter for the [`timestamp` field](TraceNotification#structfield.timestamp). + #[inline] + #[allow(clippy::type_complexity)] + pub fn timestamp(self, value: T1) -> TraceNotificationBuilder<(T0, T1)> where - T: ::planus::WriteAsOffset, + T1: ::planus::WriteAsDefault, { - TraceInfoBuilder(::planus::Initialized(value)) + let (v0,) = self.0; + TraceNotificationBuilder((v0, value)) } - /// Creates an instance of the [`PliTraceInfo` variant](TraceInfo#variant.PliTraceInfo). + /// Sets the [`timestamp` field](TraceNotification#structfield.timestamp) to the default value. #[inline] - pub fn pli_trace_info( + #[allow(clippy::type_complexity)] + pub fn timestamp_as_default( self, - value: T, - ) -> TraceInfoBuilder<::planus::Initialized<3, T>> + ) -> TraceNotificationBuilder<(T0, ::planus::DefaultValue)> { + self.timestamp(::planus::DefaultValue) + } + } + + impl TraceNotificationBuilder<(T0, T1)> { + /// Setter for the [`direction` field](TraceNotification#structfield.direction). + #[inline] + #[allow(clippy::type_complexity)] + pub fn direction(self, value: T2) -> TraceNotificationBuilder<(T0, T1, T2)> where - T: ::planus::WriteAsOffset, + T2: ::planus::WriteAsDefault, { - TraceInfoBuilder(::planus::Initialized(value)) + let (v0, v1) = self.0; + TraceNotificationBuilder((v0, v1, value)) } - /// Creates an instance of the [`RtpTraceInfo` variant](TraceInfo#variant.RtpTraceInfo). + /// Sets the [`direction` field](TraceNotification#structfield.direction) to the default value. #[inline] - pub fn rtp_trace_info( + #[allow(clippy::type_complexity)] + pub fn direction_as_default( self, - value: T, - ) -> TraceInfoBuilder<::planus::Initialized<4, T>> + ) -> TraceNotificationBuilder<(T0, T1, ::planus::DefaultValue)> { + self.direction(::planus::DefaultValue) + } + } + + impl TraceNotificationBuilder<(T0, T1, T2)> { + /// Setter for the [`info` field](TraceNotification#structfield.info). + #[inline] + #[allow(clippy::type_complexity)] + pub fn info(self, value: T3) -> TraceNotificationBuilder<(T0, T1, T2, T3)> where - T: ::planus::WriteAsOffset, + T3: ::planus::WriteAsOptionalUnion, { - TraceInfoBuilder(::planus::Initialized(value)) + let (v0, v1, v2) = self.0; + TraceNotificationBuilder((v0, v1, v2, value)) + } + + /// Sets the [`info` field](TraceNotification#structfield.info) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn info_as_null(self) -> TraceNotificationBuilder<(T0, T1, T2, ())> { + self.info(()) } } - impl TraceInfoBuilder<::planus::Initialized> { - /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [TraceInfo]. + impl TraceNotificationBuilder<(T0, T1, T2, T3)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TraceNotification]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset + ) -> ::planus::Offset where - Self: ::planus::WriteAsUnion, + Self: ::planus::WriteAsOffset, { - ::planus::WriteAsUnion::prepare(&self, builder) + ::planus::WriteAsOffset::prepare(&self, builder) } } - impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAs<::planus::Offset> + for TraceNotificationBuilder<(T0, T1, T2, T3)> { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) - } - } + type Prepared = ::planus::Offset; - impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, + + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOptional<::planus::Offset> + for TraceNotificationBuilder<(T0, T1, T2, T3)> { + type Prepared = ::planus::Offset; + #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, + impl< + T0: ::planus::WriteAsDefault, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptionalUnion, + > ::planus::WriteAsOffset + for TraceNotificationBuilder<(T0, T1, T2, T3)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Offset { + let (v0, v1, v2, v3) = &self.0; + TraceNotification::create(builder, v0, v1, v2, v3) } } - impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Reference to a deserialized [TraceNotification]. + #[derive(Copy, Clone)] + pub struct TraceNotificationRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> TraceNotificationRef<'a> { + /// Getter for the [`type` field](TraceNotification#structfield.type_). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(3, (self.0).0.prepare(builder).downcast()) + pub fn type_(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "TraceNotification", "type_")? + .unwrap_or(self::TraceType::Keyframe), + ) } - } - impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<3, T>> - where - T: ::planus::WriteAsOffset, - { + /// Getter for the [`timestamp` field](TraceNotification#structfield.timestamp). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + pub fn timestamp(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "TraceNotification", "timestamp")? + .unwrap_or(0), + ) } - } - impl ::planus::WriteAsUnion for TraceInfoBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + + /// Getter for the [`direction` field](TraceNotification#structfield.direction). #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(4, (self.0).0.prepare(builder).downcast()) + pub fn direction(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(2, "TraceNotification", "direction")? + .unwrap_or(self::TraceDirection::DirectionIn), + ) } - } - impl ::planus::WriteAsOptionalUnion for TraceInfoBuilder<::planus::Initialized<4, T>> - where - T: ::planus::WriteAsOffset, - { + /// Getter for the [`info` field](TraceNotification#structfield.info). #[inline] - fn prepare( + pub fn info( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + ) -> ::planus::Result<::core::option::Option>> + { + self.0.access_union(3, "TraceNotification", "info") } } - /// Reference to a deserialized [TraceInfo]. - #[derive(Copy, Clone, Debug)] - pub enum TraceInfoRef<'a> { - KeyFrameTraceInfo(self::KeyFrameTraceInfoRef<'a>), - FirTraceInfo(self::FirTraceInfoRef<'a>), - PliTraceInfo(self::PliTraceInfoRef<'a>), - RtpTraceInfo(self::RtpTraceInfoRef<'a>), + impl<'a> ::core::fmt::Debug for TraceNotificationRef<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut f = f.debug_struct("TraceNotificationRef"); + f.field("type_", &self.type_()); + f.field("timestamp", &self.timestamp()); + f.field("direction", &self.direction()); + if let ::core::option::Option::Some(field_info) = self.info().transpose() { + f.field("info", &field_info); + } + f.finish() + } } - impl<'a> ::core::convert::TryFrom> for TraceInfo { + impl<'a> ::core::convert::TryFrom> for TraceNotification { type Error = ::planus::Error; - fn try_from(value: TraceInfoRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - TraceInfoRef::KeyFrameTraceInfo(value) => { - Self::KeyFrameTraceInfo(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - TraceInfoRef::FirTraceInfo(value) => { - Self::FirTraceInfo(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - TraceInfoRef::PliTraceInfo(value) => { - Self::PliTraceInfo(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - - TraceInfoRef::RtpTraceInfo(value) => { - Self::RtpTraceInfo(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + #[allow(unreachable_code)] + fn try_from(value: TraceNotificationRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(Self { + type_: ::core::convert::TryInto::try_into(value.type_()?)?, + timestamp: ::core::convert::TryInto::try_into(value.timestamp()?)?, + direction: ::core::convert::TryInto::try_into(value.direction()?)?, + info: if let ::core::option::Option::Some(info) = value.info()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(info)?) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableReadUnion<'a> for TraceInfoRef<'a> { + impl<'a> ::planus::TableRead<'a> for TraceNotificationRef<'a> { + #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, + offset: usize, ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::KeyFrameTraceInfo( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::FirTraceInfo( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 3 => ::core::result::Result::Ok(Self::PliTraceInfo( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 4 => ::core::result::Result::Ok(Self::RtpTraceInfo( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), + ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( + buffer, offset, + )?)) + } + } + + impl<'a> ::planus::VectorReadInner<'a> for TraceNotificationRef<'a> { + type Error = ::planus::Error; + const STRIDE: usize = 4; + + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'a>, + offset: usize, + ) -> ::planus::Result { + ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + error_kind.with_error_location( + "[TraceNotificationRef]", + "get", + buffer.offset_from_start, + ) + }) + } + } + + impl ::planus::VectorWrite<::planus::Offset> for TraceNotification { + type Value = ::planus::Offset; + const STRIDE: usize = 4; + #[inline] + fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { + ::planus::WriteAs::prepare(self, builder) + } + + #[inline] + unsafe fn write_values( + values: &[::planus::Offset], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - (Self::STRIDE * i) as u32, + ); } } } - /// The table `KeyFrameTraceInfo` in the namespace `FBS.Producer` + impl<'a> ::planus::ReadAsRoot<'a> for TraceNotificationRef<'a> { + fn read_as_root(slice: &'a [u8]) -> ::planus::Result { + ::planus::TableRead::from_buffer( + ::planus::SliceWithStartOffset { + buffer: slice, + offset_from_start: 0, + }, + 0, + ) + .map_err(|error_kind| { + error_kind.with_error_location("[TraceNotificationRef]", "read_as_root", 0) + }) + } + } + } + /// The namespace `FBS.PipeTransport` + /// + /// Generated from these locations: + /// * File `../worker/fbs/pipeTransport.fbs` + pub mod pipe_transport { + /// The table `PipeTransportOptions` in the namespace `FBS.PipeTransport` /// /// Generated from these locations: - /// * Table `KeyFrameTraceInfo` in the file `../worker/fbs/producer.fbs:58` + /// * Table `PipeTransportOptions` in the file `../worker/fbs/pipeTransport.fbs:6` #[derive( Clone, Debug, @@ -67633,42 +69458,63 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct KeyFrameTraceInfo { - /// The field `is_rtx` in the table `KeyFrameTraceInfo` - pub is_rtx: bool, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for KeyFrameTraceInfo { - fn default() -> Self { - Self { is_rtx: false } - } + pub struct PipeTransportOptions { + /// The field `base` in the table `PipeTransportOptions` + pub base: ::planus::alloc::boxed::Box, + /// The field `listen_info` in the table `PipeTransportOptions` + pub listen_info: ::planus::alloc::boxed::Box, + /// The field `enable_rtx` in the table `PipeTransportOptions` + pub enable_rtx: bool, + /// The field `enable_srtp` in the table `PipeTransportOptions` + pub enable_srtp: bool, } - impl KeyFrameTraceInfo { - /// Creates a [KeyFrameTraceInfoBuilder] for serializing an instance of this table. + impl PipeTransportOptions { + /// Creates a [PipeTransportOptionsBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> KeyFrameTraceInfoBuilder<()> { - KeyFrameTraceInfoBuilder(()) + pub fn builder() -> PipeTransportOptionsBuilder<()> { + PipeTransportOptionsBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_is_rtx: impl ::planus::WriteAsDefault, + field_base: impl ::planus::WriteAs<::planus::Offset>, + field_listen_info: impl ::planus::WriteAs< + ::planus::Offset, + >, + field_enable_rtx: impl ::planus::WriteAsDefault, + field_enable_srtp: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_is_rtx = field_is_rtx.prepare(builder, &false); + let prepared_base = field_base.prepare(builder); + let prepared_listen_info = field_listen_info.prepare(builder); + let prepared_enable_rtx = field_enable_rtx.prepare(builder, &false); + let prepared_enable_srtp = field_enable_srtp.prepare(builder, &false); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<12> = ::core::default::Default::default(); - if prepared_is_rtx.is_some() { - table_writer.write_entry::(0); + table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); + if prepared_enable_rtx.is_some() { + table_writer.write_entry::(2); + } + if prepared_enable_srtp.is_some() { + table_writer.write_entry::(3); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_is_rtx) = prepared_is_rtx { - object_writer.write::<_, _, 1>(&prepared_is_rtx); + object_writer.write::<_, _, 4>(&prepared_base); + object_writer.write::<_, _, 4>(&prepared_listen_info); + if let ::core::option::Option::Some(prepared_enable_rtx) = + prepared_enable_rtx + { + object_writer.write::<_, _, 1>(&prepared_enable_rtx); + } + if let ::core::option::Option::Some(prepared_enable_srtp) = + prepared_enable_srtp + { + object_writer.write::<_, _, 1>(&prepared_enable_srtp); } }); } @@ -67676,161 +69522,267 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for KeyFrameTraceInfo { + impl ::planus::WriteAs<::planus::Offset> for PipeTransportOptions { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for KeyFrameTraceInfo { + impl ::planus::WriteAsOptional<::planus::Offset> for PipeTransportOptions { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for KeyFrameTraceInfo { + impl ::planus::WriteAsOffset for PipeTransportOptions { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - KeyFrameTraceInfo::create(builder, self.is_rtx) + ) -> ::planus::Offset { + PipeTransportOptions::create( + builder, + &self.base, + &self.listen_info, + self.enable_rtx, + self.enable_srtp, + ) } } - /// Builder for serializing an instance of the [KeyFrameTraceInfo] type. + /// Builder for serializing an instance of the [PipeTransportOptions] type. /// - /// Can be created using the [KeyFrameTraceInfo::builder] method. + /// Can be created using the [PipeTransportOptions::builder] method. #[derive(Debug)] #[must_use] - pub struct KeyFrameTraceInfoBuilder(State); + pub struct PipeTransportOptionsBuilder(State); - impl KeyFrameTraceInfoBuilder<()> { - /// Setter for the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx). + impl PipeTransportOptionsBuilder<()> { + /// Setter for the [`base` field](PipeTransportOptions#structfield.base). #[inline] #[allow(clippy::type_complexity)] - pub fn is_rtx(self, value: T0) -> KeyFrameTraceInfoBuilder<(T0,)> + pub fn base(self, value: T0) -> PipeTransportOptionsBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - KeyFrameTraceInfoBuilder((value,)) + PipeTransportOptionsBuilder((value,)) } + } - /// Sets the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx) to the default value. + impl PipeTransportOptionsBuilder<(T0,)> { + /// Setter for the [`listen_info` field](PipeTransportOptions#structfield.listen_info). #[inline] #[allow(clippy::type_complexity)] - pub fn is_rtx_as_default( + pub fn listen_info(self, value: T1) -> PipeTransportOptionsBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset>, + { + let (v0,) = self.0; + PipeTransportOptionsBuilder((v0, value)) + } + } + + impl PipeTransportOptionsBuilder<(T0, T1)> { + /// Setter for the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx). + #[inline] + #[allow(clippy::type_complexity)] + pub fn enable_rtx(self, value: T2) -> PipeTransportOptionsBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsDefault, + { + let (v0, v1) = self.0; + PipeTransportOptionsBuilder((v0, v1, value)) + } + + /// Sets the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn enable_rtx_as_default( self, - ) -> KeyFrameTraceInfoBuilder<(::planus::DefaultValue,)> { - self.is_rtx(::planus::DefaultValue) + ) -> PipeTransportOptionsBuilder<(T0, T1, ::planus::DefaultValue)> { + self.enable_rtx(::planus::DefaultValue) } } - impl KeyFrameTraceInfoBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [KeyFrameTraceInfo]. + impl PipeTransportOptionsBuilder<(T0, T1, T2)> { + /// Setter for the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp). + #[inline] + #[allow(clippy::type_complexity)] + pub fn enable_srtp( + self, + value: T3, + ) -> PipeTransportOptionsBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAsDefault, + { + let (v0, v1, v2) = self.0; + PipeTransportOptionsBuilder((v0, v1, v2, value)) + } + + /// Sets the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn enable_srtp_as_default( + self, + ) -> PipeTransportOptionsBuilder<(T0, T1, T2, ::planus::DefaultValue)> + { + self.enable_srtp(::planus::DefaultValue) + } + } + + impl PipeTransportOptionsBuilder<(T0, T1, T2, T3)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PipeTransportOptions]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl> - ::planus::WriteAs<::planus::Offset> - for KeyFrameTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> + for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl> - ::planus::WriteAsOptional<::planus::Offset> - for KeyFrameTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl> - ::planus::WriteAsOffset for KeyFrameTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset + for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - KeyFrameTraceInfo::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1, v2, v3) = &self.0; + PipeTransportOptions::create(builder, v0, v1, v2, v3) } } - /// Reference to a deserialized [KeyFrameTraceInfo]. + /// Reference to a deserialized [PipeTransportOptions]. #[derive(Copy, Clone)] - pub struct KeyFrameTraceInfoRef<'a>(::planus::table_reader::Table<'a>); + pub struct PipeTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> KeyFrameTraceInfoRef<'a> { - /// Getter for the [`is_rtx` field](KeyFrameTraceInfo#structfield.is_rtx). + impl<'a> PipeTransportOptionsRef<'a> { + /// Getter for the [`base` field](PipeTransportOptions#structfield.base). #[inline] - pub fn is_rtx(&self) -> ::planus::Result { + pub fn base(&self) -> ::planus::Result> { + self.0.access_required(0, "PipeTransportOptions", "base") + } + + /// Getter for the [`listen_info` field](PipeTransportOptions#structfield.listen_info). + #[inline] + pub fn listen_info(&self) -> ::planus::Result> { + self.0 + .access_required(1, "PipeTransportOptions", "listen_info") + } + + /// Getter for the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx). + #[inline] + pub fn enable_rtx(&self) -> ::planus::Result { ::core::result::Result::Ok( self.0 - .access(0, "KeyFrameTraceInfo", "is_rtx")? + .access(2, "PipeTransportOptions", "enable_rtx")? + .unwrap_or(false), + ) + } + + /// Getter for the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp). + #[inline] + pub fn enable_srtp(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(3, "PipeTransportOptions", "enable_srtp")? .unwrap_or(false), ) } } - impl<'a> ::core::fmt::Debug for KeyFrameTraceInfoRef<'a> { + impl<'a> ::core::fmt::Debug for PipeTransportOptionsRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("KeyFrameTraceInfoRef"); - f.field("is_rtx", &self.is_rtx()); + let mut f = f.debug_struct("PipeTransportOptionsRef"); + f.field("base", &self.base()); + f.field("listen_info", &self.listen_info()); + f.field("enable_rtx", &self.enable_rtx()); + f.field("enable_srtp", &self.enable_srtp()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for KeyFrameTraceInfo { + impl<'a> ::core::convert::TryFrom> for PipeTransportOptions { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: KeyFrameTraceInfoRef<'a>) -> ::planus::Result { + fn try_from(value: PipeTransportOptionsRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - is_rtx: ::core::convert::TryInto::try_into(value.is_rtx()?)?, + base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( + value.base()?, + )?), + listen_info: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.listen_info()?)?, + ), + enable_rtx: ::core::convert::TryInto::try_into(value.enable_rtx()?)?, + enable_srtp: ::core::convert::TryInto::try_into(value.enable_srtp()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for KeyFrameTraceInfoRef<'a> { + impl<'a> ::planus::TableRead<'a> for PipeTransportOptionsRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -67842,7 +69794,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for KeyFrameTraceInfoRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for PipeTransportOptionsRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -67852,7 +69804,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[KeyFrameTraceInfoRef]", + "[PipeTransportOptionsRef]", "get", buffer.offset_from_start, ) @@ -67860,8 +69812,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for KeyFrameTraceInfo { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for PipeTransportOptions { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -67870,7 +69822,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -67885,7 +69837,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for KeyFrameTraceInfoRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for PipeTransportOptionsRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -67895,15 +69847,19 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[KeyFrameTraceInfoRef]", "read_as_root", 0) + error_kind.with_error_location( + "[PipeTransportOptionsRef]", + "read_as_root", + 0, + ) }) } } - /// The table `FirTraceInfo` in the namespace `FBS.Producer` + /// The table `ConnectRequest` in the namespace `FBS.PipeTransport` /// /// Generated from these locations: - /// * Table `FirTraceInfo` in the file `../worker/fbs/producer.fbs:62` + /// * Table `ConnectRequest` in the file `../worker/fbs/pipeTransport.fbs:13` #[derive( Clone, Debug, @@ -67915,42 +69871,57 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct FirTraceInfo { - /// The field `ssrc` in the table `FirTraceInfo` - pub ssrc: u32, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for FirTraceInfo { - fn default() -> Self { - Self { ssrc: 0 } - } + pub struct ConnectRequest { + /// The field `ip` in the table `ConnectRequest` + pub ip: ::planus::alloc::string::String, + /// The field `port` in the table `ConnectRequest` + pub port: ::core::option::Option, + /// The field `srtp_parameters` in the table `ConnectRequest` + pub srtp_parameters: ::core::option::Option< + ::planus::alloc::boxed::Box, + >, } - impl FirTraceInfo { - /// Creates a [FirTraceInfoBuilder] for serializing an instance of this table. + impl ConnectRequest { + /// Creates a [ConnectRequestBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> FirTraceInfoBuilder<()> { - FirTraceInfoBuilder(()) + pub fn builder() -> ConnectRequestBuilder<()> { + ConnectRequestBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ssrc: impl ::planus::WriteAsDefault, + field_ip: impl ::planus::WriteAs<::planus::Offset>, + field_port: impl ::planus::WriteAsOptional, + field_srtp_parameters: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, ) -> ::planus::Offset { - let prepared_ssrc = field_ssrc.prepare(builder, &0); + let prepared_ip = field_ip.prepare(builder); + let prepared_port = field_port.prepare(builder); + let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - if prepared_ssrc.is_some() { - table_writer.write_entry::(0); + let mut table_writer: ::planus::table_writer::TableWriter<10> = + ::core::default::Default::default(); + table_writer.write_entry::<::planus::Offset>(0); + if prepared_srtp_parameters.is_some() { + table_writer.write_entry::<::planus::Offset>(2); + } + if prepared_port.is_some() { + table_writer.write_entry::(1); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { - object_writer.write::<_, _, 4>(&prepared_ssrc); + object_writer.write::<_, _, 4>(&prepared_ip); + if let ::core::option::Option::Some(prepared_srtp_parameters) = + prepared_srtp_parameters + { + object_writer.write::<_, _, 4>(&prepared_srtp_parameters); + } + if let ::core::option::Option::Some(prepared_port) = prepared_port { + object_writer.write::<_, _, 2>(&prepared_port); } }); } @@ -67958,156 +69929,243 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for FirTraceInfo { + impl ::planus::WriteAs<::planus::Offset> for ConnectRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for FirTraceInfo { + impl ::planus::WriteAsOptional<::planus::Offset> for ConnectRequest { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for FirTraceInfo { + impl ::planus::WriteAsOffset for ConnectRequest { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - FirTraceInfo::create(builder, self.ssrc) + ) -> ::planus::Offset { + ConnectRequest::create(builder, &self.ip, self.port, &self.srtp_parameters) } } - /// Builder for serializing an instance of the [FirTraceInfo] type. + /// Builder for serializing an instance of the [ConnectRequest] type. /// - /// Can be created using the [FirTraceInfo::builder] method. + /// Can be created using the [ConnectRequest::builder] method. #[derive(Debug)] #[must_use] - pub struct FirTraceInfoBuilder(State); + pub struct ConnectRequestBuilder(State); - impl FirTraceInfoBuilder<()> { - /// Setter for the [`ssrc` field](FirTraceInfo#structfield.ssrc). + impl ConnectRequestBuilder<()> { + /// Setter for the [`ip` field](ConnectRequest#structfield.ip). #[inline] #[allow(clippy::type_complexity)] - pub fn ssrc(self, value: T0) -> FirTraceInfoBuilder<(T0,)> + pub fn ip(self, value: T0) -> ConnectRequestBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - FirTraceInfoBuilder((value,)) + ConnectRequestBuilder((value,)) } + } - /// Sets the [`ssrc` field](FirTraceInfo#structfield.ssrc) to the default value. + impl ConnectRequestBuilder<(T0,)> { + /// Setter for the [`port` field](ConnectRequest#structfield.port). #[inline] #[allow(clippy::type_complexity)] - pub fn ssrc_as_default(self) -> FirTraceInfoBuilder<(::planus::DefaultValue,)> { - self.ssrc(::planus::DefaultValue) + pub fn port(self, value: T1) -> ConnectRequestBuilder<(T0, T1)> + where + T1: ::planus::WriteAsOptional, + { + let (v0,) = self.0; + ConnectRequestBuilder((v0, value)) + } + + /// Sets the [`port` field](ConnectRequest#structfield.port) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn port_as_null(self) -> ConnectRequestBuilder<(T0, ())> { + self.port(()) } } - impl FirTraceInfoBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [FirTraceInfo]. + impl ConnectRequestBuilder<(T0, T1)> { + /// Setter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters(self, value: T2) -> ConnectRequestBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + { + let (v0, v1) = self.0; + ConnectRequestBuilder((v0, v1, value)) + } + + /// Sets the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters_as_null(self) -> ConnectRequestBuilder<(T0, T1, ())> { + self.srtp_parameters(()) + } + } + + impl ConnectRequestBuilder<(T0, T1, T2)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectRequest]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl> - ::planus::WriteAs<::planus::Offset> for FirTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for ConnectRequestBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl> - ::planus::WriteAsOptional<::planus::Offset> - for FirTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for ConnectRequestBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl> ::planus::WriteAsOffset - for FirTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOffset for ConnectRequestBuilder<(T0, T1, T2)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - FirTraceInfo::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1, v2) = &self.0; + ConnectRequest::create(builder, v0, v1, v2) } } - /// Reference to a deserialized [FirTraceInfo]. + /// Reference to a deserialized [ConnectRequest]. #[derive(Copy, Clone)] - pub struct FirTraceInfoRef<'a>(::planus::table_reader::Table<'a>); + pub struct ConnectRequestRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> FirTraceInfoRef<'a> { - /// Getter for the [`ssrc` field](FirTraceInfo#structfield.ssrc). + impl<'a> ConnectRequestRef<'a> { + /// Getter for the [`ip` field](ConnectRequest#structfield.ip). #[inline] - pub fn ssrc(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0.access(0, "FirTraceInfo", "ssrc")?.unwrap_or(0), - ) + pub fn ip(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(0, "ConnectRequest", "ip") + } + + /// Getter for the [`port` field](ConnectRequest#structfield.port). + #[inline] + pub fn port(&self) -> ::planus::Result<::core::option::Option> { + self.0.access(1, "ConnectRequest", "port") + } + + /// Getter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + #[inline] + pub fn srtp_parameters( + &self, + ) -> ::planus::Result< + ::core::option::Option>, + > { + self.0.access(2, "ConnectRequest", "srtp_parameters") } } - impl<'a> ::core::fmt::Debug for FirTraceInfoRef<'a> { + impl<'a> ::core::fmt::Debug for ConnectRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("FirTraceInfoRef"); - f.field("ssrc", &self.ssrc()); + let mut f = f.debug_struct("ConnectRequestRef"); + f.field("ip", &self.ip()); + if let ::core::option::Option::Some(field_port) = self.port().transpose() { + f.field("port", &field_port); + } + if let ::core::option::Option::Some(field_srtp_parameters) = + self.srtp_parameters().transpose() + { + f.field("srtp_parameters", &field_srtp_parameters); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for FirTraceInfo { + impl<'a> ::core::convert::TryFrom> for ConnectRequest { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: FirTraceInfoRef<'a>) -> ::planus::Result { + fn try_from(value: ConnectRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, + ip: ::core::convert::TryInto::try_into(value.ip()?)?, + port: if let ::core::option::Option::Some(port) = value.port()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(port)?) + } else { + ::core::option::Option::None + }, + srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = + value.srtp_parameters()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(srtp_parameters)?, + )) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for FirTraceInfoRef<'a> { + impl<'a> ::planus::TableRead<'a> for ConnectRequestRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -68119,7 +70177,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for FirTraceInfoRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ConnectRequestRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -68129,7 +70187,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[FirTraceInfoRef]", + "[ConnectRequestRef]", "get", buffer.offset_from_start, ) @@ -68137,8 +70195,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for FirTraceInfo { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ConnectRequest { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -68147,7 +70205,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -68162,7 +70220,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for FirTraceInfoRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ConnectRequestRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -68172,15 +70230,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[FirTraceInfoRef]", "read_as_root", 0) + error_kind.with_error_location("[ConnectRequestRef]", "read_as_root", 0) }) } } - /// The table `PliTraceInfo` in the namespace `FBS.Producer` + /// The table `ConnectResponse` in the namespace `FBS.PipeTransport` /// /// Generated from these locations: - /// * Table `PliTraceInfo` in the file `../worker/fbs/producer.fbs:66` + /// * Table `ConnectResponse` in the file `../worker/fbs/pipeTransport.fbs:19` #[derive( Clone, Debug, @@ -68192,199 +70250,182 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct PliTraceInfo { - /// The field `ssrc` in the table `PliTraceInfo` - pub ssrc: u32, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for PliTraceInfo { - fn default() -> Self { - Self { ssrc: 0 } - } + pub struct ConnectResponse { + /// The field `tuple` in the table `ConnectResponse` + pub tuple: ::planus::alloc::boxed::Box, } - impl PliTraceInfo { - /// Creates a [PliTraceInfoBuilder] for serializing an instance of this table. + impl ConnectResponse { + /// Creates a [ConnectResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> PliTraceInfoBuilder<()> { - PliTraceInfoBuilder(()) + pub fn builder() -> ConnectResponseBuilder<()> { + ConnectResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ssrc: impl ::planus::WriteAsDefault, + field_tuple: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_ssrc = field_ssrc.prepare(builder, &0); + let prepared_tuple = field_tuple.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_ssrc.is_some() { - table_writer.write_entry::(0); - } + table_writer.write_entry::<::planus::Offset>(0); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_ssrc) = prepared_ssrc { - object_writer.write::<_, _, 4>(&prepared_ssrc); - } + object_writer.write::<_, _, 4>(&prepared_tuple); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for PliTraceInfo { + impl ::planus::WriteAs<::planus::Offset> for ConnectResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for PliTraceInfo { + impl ::planus::WriteAsOptional<::planus::Offset> for ConnectResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for PliTraceInfo { + impl ::planus::WriteAsOffset for ConnectResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - PliTraceInfo::create(builder, self.ssrc) + ) -> ::planus::Offset { + ConnectResponse::create(builder, &self.tuple) } } - /// Builder for serializing an instance of the [PliTraceInfo] type. + /// Builder for serializing an instance of the [ConnectResponse] type. /// - /// Can be created using the [PliTraceInfo::builder] method. + /// Can be created using the [ConnectResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct PliTraceInfoBuilder(State); + pub struct ConnectResponseBuilder(State); - impl PliTraceInfoBuilder<()> { - /// Setter for the [`ssrc` field](PliTraceInfo#structfield.ssrc). + impl ConnectResponseBuilder<()> { + /// Setter for the [`tuple` field](ConnectResponse#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn ssrc(self, value: T0) -> PliTraceInfoBuilder<(T0,)> + pub fn tuple(self, value: T0) -> ConnectResponseBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - PliTraceInfoBuilder((value,)) - } - - /// Sets the [`ssrc` field](PliTraceInfo#structfield.ssrc) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ssrc_as_default(self) -> PliTraceInfoBuilder<(::planus::DefaultValue,)> { - self.ssrc(::planus::DefaultValue) + ConnectResponseBuilder((value,)) } } - impl PliTraceInfoBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PliTraceInfo]. + impl ConnectResponseBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl> - ::planus::WriteAs<::planus::Offset> for PliTraceInfoBuilder<(T0,)> + impl>> + ::planus::WriteAs<::planus::Offset> + for ConnectResponseBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl> - ::planus::WriteAsOptional<::planus::Offset> - for PliTraceInfoBuilder<(T0,)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for ConnectResponseBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl> ::planus::WriteAsOffset - for PliTraceInfoBuilder<(T0,)> + impl>> + ::planus::WriteAsOffset for ConnectResponseBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0,) = &self.0; - PliTraceInfo::create(builder, v0) + ConnectResponse::create(builder, v0) } } - /// Reference to a deserialized [PliTraceInfo]. + /// Reference to a deserialized [ConnectResponse]. #[derive(Copy, Clone)] - pub struct PliTraceInfoRef<'a>(::planus::table_reader::Table<'a>); + pub struct ConnectResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> PliTraceInfoRef<'a> { - /// Getter for the [`ssrc` field](PliTraceInfo#structfield.ssrc). + impl<'a> ConnectResponseRef<'a> { + /// Getter for the [`tuple` field](ConnectResponse#structfield.tuple). #[inline] - pub fn ssrc(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0.access(0, "PliTraceInfo", "ssrc")?.unwrap_or(0), - ) + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(0, "ConnectResponse", "tuple") } } - impl<'a> ::core::fmt::Debug for PliTraceInfoRef<'a> { + impl<'a> ::core::fmt::Debug for ConnectResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("PliTraceInfoRef"); - f.field("ssrc", &self.ssrc()); + let mut f = f.debug_struct("ConnectResponseRef"); + f.field("tuple", &self.tuple()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for PliTraceInfo { + impl<'a> ::core::convert::TryFrom> for ConnectResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: PliTraceInfoRef<'a>) -> ::planus::Result { + fn try_from(value: ConnectResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ssrc: ::core::convert::TryInto::try_into(value.ssrc()?)?, + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for PliTraceInfoRef<'a> { + impl<'a> ::planus::TableRead<'a> for ConnectResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -68396,7 +70437,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for PliTraceInfoRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ConnectResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -68406,7 +70447,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[PliTraceInfoRef]", + "[ConnectResponseRef]", "get", buffer.offset_from_start, ) @@ -68414,8 +70455,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for PliTraceInfo { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ConnectResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -68424,7 +70465,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -68439,7 +70480,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for PliTraceInfoRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ConnectResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -68449,15 +70490,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[PliTraceInfoRef]", "read_as_root", 0) + error_kind.with_error_location("[ConnectResponseRef]", "read_as_root", 0) }) } } - /// The table `RtpTraceInfo` in the namespace `FBS.Producer` + /// The table `DumpResponse` in the namespace `FBS.PipeTransport` /// /// Generated from these locations: - /// * Table `RtpTraceInfo` in the file `../worker/fbs/producer.fbs:70` + /// * Table `DumpResponse` in the file `../worker/fbs/pipeTransport.fbs:23` #[derive( Clone, Debug, @@ -68469,42 +70510,63 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct RtpTraceInfo { - /// The field `is_rtx` in the table `RtpTraceInfo` - pub is_rtx: bool, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for RtpTraceInfo { - fn default() -> Self { - Self { is_rtx: false } - } + pub struct DumpResponse { + /// The field `base` in the table `DumpResponse` + pub base: ::planus::alloc::boxed::Box, + /// The field `tuple` in the table `DumpResponse` + pub tuple: ::planus::alloc::boxed::Box, + /// The field `rtx` in the table `DumpResponse` + pub rtx: bool, + /// The field `srtp_parameters` in the table `DumpResponse` + pub srtp_parameters: ::core::option::Option< + ::planus::alloc::boxed::Box, + >, } - impl RtpTraceInfo { - /// Creates a [RtpTraceInfoBuilder] for serializing an instance of this table. + impl DumpResponse { + /// Creates a [DumpResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> RtpTraceInfoBuilder<()> { - RtpTraceInfoBuilder(()) + pub fn builder() -> DumpResponseBuilder<()> { + DumpResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_is_rtx: impl ::planus::WriteAsDefault, + field_base: impl ::planus::WriteAs<::planus::Offset>, + field_tuple: impl ::planus::WriteAs<::planus::Offset>, + field_rtx: impl ::planus::WriteAsDefault, + field_srtp_parameters: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, ) -> ::planus::Offset { - let prepared_is_rtx = field_is_rtx.prepare(builder, &false); + let prepared_base = field_base.prepare(builder); + let prepared_tuple = field_tuple.prepare(builder); + let prepared_rtx = field_rtx.prepare(builder, &false); + let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<12> = ::core::default::Default::default(); - if prepared_is_rtx.is_some() { - table_writer.write_entry::(0); + table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); + if prepared_srtp_parameters.is_some() { + table_writer.write_entry::<::planus::Offset>(3); + } + if prepared_rtx.is_some() { + table_writer.write_entry::(2); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_is_rtx) = prepared_is_rtx { - object_writer.write::<_, _, 1>(&prepared_is_rtx); + object_writer.write::<_, _, 4>(&prepared_base); + object_writer.write::<_, _, 4>(&prepared_tuple); + if let ::core::option::Option::Some(prepared_srtp_parameters) = + prepared_srtp_parameters + { + object_writer.write::<_, _, 4>(&prepared_srtp_parameters); + } + if let ::core::option::Option::Some(prepared_rtx) = prepared_rtx { + object_writer.write::<_, _, 1>(&prepared_rtx); } }); } @@ -68512,156 +70574,275 @@ mod root { } } - impl ::planus::WriteAs<::planus::Offset> for RtpTraceInfo { + impl ::planus::WriteAs<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for RtpTraceInfo { + impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for RtpTraceInfo { + impl ::planus::WriteAsOffset for DumpResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - RtpTraceInfo::create(builder, self.is_rtx) + ) -> ::planus::Offset { + DumpResponse::create( + builder, + &self.base, + &self.tuple, + self.rtx, + &self.srtp_parameters, + ) } } - /// Builder for serializing an instance of the [RtpTraceInfo] type. + /// Builder for serializing an instance of the [DumpResponse] type. /// - /// Can be created using the [RtpTraceInfo::builder] method. + /// Can be created using the [DumpResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct RtpTraceInfoBuilder(State); + pub struct DumpResponseBuilder(State); - impl RtpTraceInfoBuilder<()> { - /// Setter for the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx). + impl DumpResponseBuilder<()> { + /// Setter for the [`base` field](DumpResponse#structfield.base). #[inline] #[allow(clippy::type_complexity)] - pub fn is_rtx(self, value: T0) -> RtpTraceInfoBuilder<(T0,)> + pub fn base(self, value: T0) -> DumpResponseBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - RtpTraceInfoBuilder((value,)) + DumpResponseBuilder((value,)) + } + } + + impl DumpResponseBuilder<(T0,)> { + /// Setter for the [`tuple` field](DumpResponse#structfield.tuple). + #[inline] + #[allow(clippy::type_complexity)] + pub fn tuple(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset>, + { + let (v0,) = self.0; + DumpResponseBuilder((v0, value)) + } + } + + impl DumpResponseBuilder<(T0, T1)> { + /// Setter for the [`rtx` field](DumpResponse#structfield.rtx). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtx(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsDefault, + { + let (v0, v1) = self.0; + DumpResponseBuilder((v0, v1, value)) + } + + /// Sets the [`rtx` field](DumpResponse#structfield.rtx) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtx_as_default( + self, + ) -> DumpResponseBuilder<(T0, T1, ::planus::DefaultValue)> { + self.rtx(::planus::DefaultValue) + } + } + + impl DumpResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + { + let (v0, v1, v2) = self.0; + DumpResponseBuilder((v0, v1, v2, value)) } - /// Sets the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx) to the default value. + /// Sets the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn is_rtx_as_default(self) -> RtpTraceInfoBuilder<(::planus::DefaultValue,)> { - self.is_rtx(::planus::DefaultValue) + pub fn srtp_parameters_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, ())> { + self.srtp_parameters(()) } } - impl RtpTraceInfoBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [RtpTraceInfo]. + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl> - ::planus::WriteAs<::planus::Offset> for RtpTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl> - ::planus::WriteAsOptional<::planus::Offset> - for RtpTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for DumpResponseBuilder<(T0, T1, T2, T3)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl> ::planus::WriteAsOffset - for RtpTraceInfoBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOffset for DumpResponseBuilder<(T0, T1, T2, T3)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - RtpTraceInfo::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1, v2, v3) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3) } } - /// Reference to a deserialized [RtpTraceInfo]. + /// Reference to a deserialized [DumpResponse]. #[derive(Copy, Clone)] - pub struct RtpTraceInfoRef<'a>(::planus::table_reader::Table<'a>); + pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> RtpTraceInfoRef<'a> { - /// Getter for the [`is_rtx` field](RtpTraceInfo#structfield.is_rtx). + impl<'a> DumpResponseRef<'a> { + /// Getter for the [`base` field](DumpResponse#structfield.base). #[inline] - pub fn is_rtx(&self) -> ::planus::Result { + pub fn base(&self) -> ::planus::Result> { + self.0.access_required(0, "DumpResponse", "base") + } + + /// Getter for the [`tuple` field](DumpResponse#structfield.tuple). + #[inline] + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(1, "DumpResponse", "tuple") + } + + /// Getter for the [`rtx` field](DumpResponse#structfield.rtx). + #[inline] + pub fn rtx(&self) -> ::planus::Result { ::core::result::Result::Ok( - self.0.access(0, "RtpTraceInfo", "is_rtx")?.unwrap_or(false), + self.0.access(2, "DumpResponse", "rtx")?.unwrap_or(false), ) } + + /// Getter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + #[inline] + pub fn srtp_parameters( + &self, + ) -> ::planus::Result< + ::core::option::Option>, + > { + self.0.access(3, "DumpResponse", "srtp_parameters") + } } - impl<'a> ::core::fmt::Debug for RtpTraceInfoRef<'a> { + impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("RtpTraceInfoRef"); - f.field("is_rtx", &self.is_rtx()); + let mut f = f.debug_struct("DumpResponseRef"); + f.field("base", &self.base()); + f.field("tuple", &self.tuple()); + f.field("rtx", &self.rtx()); + if let ::core::option::Option::Some(field_srtp_parameters) = + self.srtp_parameters().transpose() + { + f.field("srtp_parameters", &field_srtp_parameters); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for RtpTraceInfo { + impl<'a> ::core::convert::TryFrom> for DumpResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: RtpTraceInfoRef<'a>) -> ::planus::Result { + fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - is_rtx: ::core::convert::TryInto::try_into(value.is_rtx()?)?, + base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( + value.base()?, + )?), + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, + ), + rtx: ::core::convert::TryInto::try_into(value.rtx()?)?, + srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = + value.srtp_parameters()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(srtp_parameters)?, + )) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for RtpTraceInfoRef<'a> { + impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -68673,7 +70854,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for RtpTraceInfoRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -68683,7 +70864,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[RtpTraceInfoRef]", + "[DumpResponseRef]", "get", buffer.offset_from_start, ) @@ -68691,8 +70872,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for RtpTraceInfo { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -68701,7 +70882,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -68716,7 +70897,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for RtpTraceInfoRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -68726,397 +70907,229 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[RtpTraceInfoRef]", "read_as_root", 0) + error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) }) } } - /// The table `TraceNotification` in the namespace `FBS.Producer` + /// The table `GetStatsResponse` in the namespace `FBS.PipeTransport` /// /// Generated from these locations: - /// * Table `TraceNotification` in the file `../worker/fbs/producer.fbs:74` + /// * Table `GetStatsResponse` in the file `../worker/fbs/pipeTransport.fbs:30` #[derive( - Clone, - Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, + Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] - pub struct TraceNotification { - /// The field `type` in the table `TraceNotification` - pub type_: self::TraceType, - /// The field `timestamp` in the table `TraceNotification` - pub timestamp: u64, - /// The field `direction` in the table `TraceNotification` - pub direction: self::TraceDirection, - /// The field `info` in the table `TraceNotification` - pub info: ::core::option::Option, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for TraceNotification { - fn default() -> Self { - Self { - type_: self::TraceType::Keyframe, - timestamp: 0, - direction: self::TraceDirection::DirectionIn, - info: ::core::default::Default::default(), - } - } + pub struct GetStatsResponse { + /// The field `base` in the table `GetStatsResponse` + pub base: ::planus::alloc::boxed::Box, + /// The field `tuple` in the table `GetStatsResponse` + pub tuple: ::planus::alloc::boxed::Box, } - impl TraceNotification { - /// Creates a [TraceNotificationBuilder] for serializing an instance of this table. + impl GetStatsResponse { + /// Creates a [GetStatsResponseBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> TraceNotificationBuilder<()> { - TraceNotificationBuilder(()) + pub fn builder() -> GetStatsResponseBuilder<()> { + GetStatsResponseBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_type_: impl ::planus::WriteAsDefault, - field_timestamp: impl ::planus::WriteAsDefault, - field_direction: impl ::planus::WriteAsDefault< - self::TraceDirection, - self::TraceDirection, - >, - field_info: impl ::planus::WriteAsOptionalUnion, + field_base: impl ::planus::WriteAs<::planus::Offset>, + field_tuple: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_type_ = field_type_.prepare(builder, &self::TraceType::Keyframe); - let prepared_timestamp = field_timestamp.prepare(builder, &0); - let prepared_direction = - field_direction.prepare(builder, &self::TraceDirection::DirectionIn); - let prepared_info = field_info.prepare(builder); + let prepared_base = field_base.prepare(builder); + let prepared_tuple = field_tuple.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<14> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - if prepared_timestamp.is_some() { - table_writer.write_entry::(1); - } - if prepared_info.is_some() { - table_writer.write_entry::<::planus::Offset>(4); - } - if prepared_type_.is_some() { - table_writer.write_entry::(0); - } - if prepared_direction.is_some() { - table_writer.write_entry::(2); - } - if prepared_info.is_some() { - table_writer.write_entry::(3); - } + table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(1); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_timestamp) = - prepared_timestamp - { - object_writer.write::<_, _, 8>(&prepared_timestamp); - } - if let ::core::option::Option::Some(prepared_info) = prepared_info { - object_writer.write::<_, _, 4>(&prepared_info.offset()); - } - if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { - object_writer.write::<_, _, 1>(&prepared_type_); - } - if let ::core::option::Option::Some(prepared_direction) = - prepared_direction - { - object_writer.write::<_, _, 1>(&prepared_direction); - } - if let ::core::option::Option::Some(prepared_info) = prepared_info { - object_writer.write::<_, _, 1>(&prepared_info.tag()); - } + object_writer.write::<_, _, 4>(&prepared_base); + object_writer.write::<_, _, 4>(&prepared_tuple); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for TraceNotification { + impl ::planus::WriteAs<::planus::Offset> for GetStatsResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for TraceNotification { + impl ::planus::WriteAsOptional<::planus::Offset> for GetStatsResponse { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for TraceNotification { + impl ::planus::WriteAsOffset for GetStatsResponse { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - TraceNotification::create( - builder, - self.type_, - self.timestamp, - self.direction, - &self.info, - ) + ) -> ::planus::Offset { + GetStatsResponse::create(builder, &self.base, &self.tuple) } } - /// Builder for serializing an instance of the [TraceNotification] type. + /// Builder for serializing an instance of the [GetStatsResponse] type. /// - /// Can be created using the [TraceNotification::builder] method. + /// Can be created using the [GetStatsResponse::builder] method. #[derive(Debug)] #[must_use] - pub struct TraceNotificationBuilder(State); + pub struct GetStatsResponseBuilder(State); - impl TraceNotificationBuilder<()> { - /// Setter for the [`type` field](TraceNotification#structfield.type_). + impl GetStatsResponseBuilder<()> { + /// Setter for the [`base` field](GetStatsResponse#structfield.base). #[inline] #[allow(clippy::type_complexity)] - pub fn type_(self, value: T0) -> TraceNotificationBuilder<(T0,)> + pub fn base(self, value: T0) -> GetStatsResponseBuilder<(T0,)> where - T0: ::planus::WriteAsDefault, + T0: ::planus::WriteAs<::planus::Offset>, { - TraceNotificationBuilder((value,)) - } - - /// Sets the [`type` field](TraceNotification#structfield.type_) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn type_as_default( - self, - ) -> TraceNotificationBuilder<(::planus::DefaultValue,)> { - self.type_(::planus::DefaultValue) + GetStatsResponseBuilder((value,)) } } - impl TraceNotificationBuilder<(T0,)> { - /// Setter for the [`timestamp` field](TraceNotification#structfield.timestamp). + impl GetStatsResponseBuilder<(T0,)> { + /// Setter for the [`tuple` field](GetStatsResponse#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn timestamp(self, value: T1) -> TraceNotificationBuilder<(T0, T1)> + pub fn tuple(self, value: T1) -> GetStatsResponseBuilder<(T0, T1)> where - T1: ::planus::WriteAsDefault, + T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - TraceNotificationBuilder((v0, value)) - } - - /// Sets the [`timestamp` field](TraceNotification#structfield.timestamp) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn timestamp_as_default( - self, - ) -> TraceNotificationBuilder<(T0, ::planus::DefaultValue)> { - self.timestamp(::planus::DefaultValue) - } - } - - impl TraceNotificationBuilder<(T0, T1)> { - /// Setter for the [`direction` field](TraceNotification#structfield.direction). - #[inline] - #[allow(clippy::type_complexity)] - pub fn direction(self, value: T2) -> TraceNotificationBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsDefault, - { - let (v0, v1) = self.0; - TraceNotificationBuilder((v0, v1, value)) - } - - /// Sets the [`direction` field](TraceNotification#structfield.direction) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn direction_as_default( - self, - ) -> TraceNotificationBuilder<(T0, T1, ::planus::DefaultValue)> { - self.direction(::planus::DefaultValue) - } - } - - impl TraceNotificationBuilder<(T0, T1, T2)> { - /// Setter for the [`info` field](TraceNotification#structfield.info). - #[inline] - #[allow(clippy::type_complexity)] - pub fn info(self, value: T3) -> TraceNotificationBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAsOptionalUnion, - { - let (v0, v1, v2) = self.0; - TraceNotificationBuilder((v0, v1, v2, value)) - } - - /// Sets the [`info` field](TraceNotification#structfield.info) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn info_as_null(self) -> TraceNotificationBuilder<(T0, T1, T2, ())> { - self.info(()) + GetStatsResponseBuilder((v0, value)) } } - impl TraceNotificationBuilder<(T0, T1, T2, T3)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TraceNotification]. + impl GetStatsResponseBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [GetStatsResponse]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAs<::planus::Offset> - for TraceNotificationBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> + for GetStatsResponseBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOptional<::planus::Offset> - for TraceNotificationBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for GetStatsResponseBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAsDefault, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptionalUnion, - > ::planus::WriteAsOffset - for TraceNotificationBuilder<(T0, T1, T2, T3)> + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset for GetStatsResponseBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - TraceNotification::create(builder, v0, v1, v2, v3) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + GetStatsResponse::create(builder, v0, v1) } } - /// Reference to a deserialized [TraceNotification]. + /// Reference to a deserialized [GetStatsResponse]. #[derive(Copy, Clone)] - pub struct TraceNotificationRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> TraceNotificationRef<'a> { - /// Getter for the [`type` field](TraceNotification#structfield.type_). - #[inline] - pub fn type_(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(0, "TraceNotification", "type_")? - .unwrap_or(self::TraceType::Keyframe), - ) - } - - /// Getter for the [`timestamp` field](TraceNotification#structfield.timestamp). - #[inline] - pub fn timestamp(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "TraceNotification", "timestamp")? - .unwrap_or(0), - ) - } + pub struct GetStatsResponseRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`direction` field](TraceNotification#structfield.direction). + impl<'a> GetStatsResponseRef<'a> { + /// Getter for the [`base` field](GetStatsResponse#structfield.base). #[inline] - pub fn direction(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "TraceNotification", "direction")? - .unwrap_or(self::TraceDirection::DirectionIn), - ) + pub fn base(&self) -> ::planus::Result> { + self.0.access_required(0, "GetStatsResponse", "base") } - /// Getter for the [`info` field](TraceNotification#structfield.info). + /// Getter for the [`tuple` field](GetStatsResponse#structfield.tuple). #[inline] - pub fn info( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access_union(3, "TraceNotification", "info") + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(1, "GetStatsResponse", "tuple") } } - impl<'a> ::core::fmt::Debug for TraceNotificationRef<'a> { + impl<'a> ::core::fmt::Debug for GetStatsResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("TraceNotificationRef"); - f.field("type_", &self.type_()); - f.field("timestamp", &self.timestamp()); - f.field("direction", &self.direction()); - if let ::core::option::Option::Some(field_info) = self.info().transpose() { - f.field("info", &field_info); - } + let mut f = f.debug_struct("GetStatsResponseRef"); + f.field("base", &self.base()); + f.field("tuple", &self.tuple()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for TraceNotification { + impl<'a> ::core::convert::TryFrom> for GetStatsResponse { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: TraceNotificationRef<'a>) -> ::planus::Result { + fn try_from(value: GetStatsResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - type_: ::core::convert::TryInto::try_into(value.type_()?)?, - timestamp: ::core::convert::TryInto::try_into(value.timestamp()?)?, - direction: ::core::convert::TryInto::try_into(value.direction()?)?, - info: if let ::core::option::Option::Some(info) = value.info()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(info)?) - } else { - ::core::option::Option::None - }, + base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( + value.base()?, + )?), + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for TraceNotificationRef<'a> { + impl<'a> ::planus::TableRead<'a> for GetStatsResponseRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -69128,7 +71141,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for TraceNotificationRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for GetStatsResponseRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -69138,7 +71151,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[TraceNotificationRef]", + "[GetStatsResponseRef]", "get", buffer.offset_from_start, ) @@ -69146,8 +71159,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for TraceNotification { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for GetStatsResponse { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -69156,7 +71169,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -69171,7 +71184,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for TraceNotificationRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for GetStatsResponseRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -69181,20 +71194,20 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[TraceNotificationRef]", "read_as_root", 0) + error_kind.with_error_location("[GetStatsResponseRef]", "read_as_root", 0) }) } } } - /// The namespace `FBS.PipeTransport` + /// The namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * File `../worker/fbs/pipeTransport.fbs` - pub mod pipe_transport { - /// The table `PipeTransportOptions` in the namespace `FBS.PipeTransport` + /// * File `../worker/fbs/plainTransport.fbs` + pub mod plain_transport { + /// The table `PlainTransportOptions` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `PipeTransportOptions` in the file `../worker/fbs/pipeTransport.fbs:5` + /// * Table `PlainTransportOptions` in the file `../worker/fbs/plainTransport.fbs:7` #[derive( Clone, Debug, @@ -69206,22 +71219,31 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct PipeTransportOptions { - /// The field `base` in the table `PipeTransportOptions` + pub struct PlainTransportOptions { + /// The field `base` in the table `PlainTransportOptions` pub base: ::planus::alloc::boxed::Box, - /// The field `listen_info` in the table `PipeTransportOptions` - pub listen_info: ::planus::alloc::boxed::Box, - /// The field `enable_rtx` in the table `PipeTransportOptions` - pub enable_rtx: bool, - /// The field `enable_srtp` in the table `PipeTransportOptions` + /// The field `listen_info` in the table `PlainTransportOptions` + pub listen_info: ::planus::alloc::boxed::Box, + /// The field `rtcp_listen_info` in the table `PlainTransportOptions` + pub rtcp_listen_info: ::core::option::Option< + ::planus::alloc::boxed::Box, + >, + /// The field `rtcp_mux` in the table `PlainTransportOptions` + pub rtcp_mux: bool, + /// The field `comedia` in the table `PlainTransportOptions` + pub comedia: bool, + /// The field `enable_srtp` in the table `PlainTransportOptions` pub enable_srtp: bool, + /// The field `srtp_crypto_suite` in the table `PlainTransportOptions` + pub srtp_crypto_suite: + ::core::option::Option, } - impl PipeTransportOptions { - /// Creates a [PipeTransportOptionsBuilder] for serializing an instance of this table. + impl PlainTransportOptions { + /// Creates a [PlainTransportOptionsBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> PipeTransportOptionsBuilder<()> { - PipeTransportOptionsBuilder(()) + pub fn builder() -> PlainTransportOptionsBuilder<()> { + PlainTransportOptionsBuilder(()) } #[allow(clippy::too_many_arguments)] @@ -69231,175 +71253,292 @@ mod root { field_listen_info: impl ::planus::WriteAs< ::planus::Offset, >, - field_enable_rtx: impl ::planus::WriteAsDefault, + field_rtcp_listen_info: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, + field_rtcp_mux: impl ::planus::WriteAsDefault, + field_comedia: impl ::planus::WriteAsDefault, field_enable_srtp: impl ::planus::WriteAsDefault, + field_srtp_crypto_suite: impl ::planus::WriteAsOptional< + super::srtp_parameters::SrtpCryptoSuite, + >, ) -> ::planus::Offset { let prepared_base = field_base.prepare(builder); let prepared_listen_info = field_listen_info.prepare(builder); - let prepared_enable_rtx = field_enable_rtx.prepare(builder, &false); + let prepared_rtcp_listen_info = field_rtcp_listen_info.prepare(builder); + let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); + let prepared_comedia = field_comedia.prepare(builder, &false); let prepared_enable_srtp = field_enable_srtp.prepare(builder, &false); + let prepared_srtp_crypto_suite = field_srtp_crypto_suite.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<12> = + let mut table_writer: ::planus::table_writer::TableWriter<18> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); table_writer.write_entry::<::planus::Offset>(1); - if prepared_enable_rtx.is_some() { - table_writer.write_entry::(2); + if prepared_rtcp_listen_info.is_some() { + table_writer + .write_entry::<::planus::Offset>(2); } - if prepared_enable_srtp.is_some() { + if prepared_rtcp_mux.is_some() { table_writer.write_entry::(3); } + if prepared_comedia.is_some() { + table_writer.write_entry::(4); + } + if prepared_enable_srtp.is_some() { + table_writer.write_entry::(5); + } + if prepared_srtp_crypto_suite.is_some() { + table_writer.write_entry::(6); + } unsafe { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_base); object_writer.write::<_, _, 4>(&prepared_listen_info); - if let ::core::option::Option::Some(prepared_enable_rtx) = - prepared_enable_rtx + if let ::core::option::Option::Some(prepared_rtcp_listen_info) = + prepared_rtcp_listen_info { - object_writer.write::<_, _, 1>(&prepared_enable_rtx); + object_writer.write::<_, _, 4>(&prepared_rtcp_listen_info); + } + if let ::core::option::Option::Some(prepared_rtcp_mux) = + prepared_rtcp_mux + { + object_writer.write::<_, _, 1>(&prepared_rtcp_mux); + } + if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia + { + object_writer.write::<_, _, 1>(&prepared_comedia); } if let ::core::option::Option::Some(prepared_enable_srtp) = prepared_enable_srtp { object_writer.write::<_, _, 1>(&prepared_enable_srtp); } + if let ::core::option::Option::Some(prepared_srtp_crypto_suite) = + prepared_srtp_crypto_suite + { + object_writer.write::<_, _, 1>(&prepared_srtp_crypto_suite); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for PipeTransportOptions { + impl ::planus::WriteAs<::planus::Offset> for PlainTransportOptions { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for PipeTransportOptions { + impl ::planus::WriteAsOptional<::planus::Offset> for PlainTransportOptions { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for PipeTransportOptions { + impl ::planus::WriteAsOffset for PlainTransportOptions { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - PipeTransportOptions::create( + ) -> ::planus::Offset { + PlainTransportOptions::create( builder, &self.base, &self.listen_info, - self.enable_rtx, + &self.rtcp_listen_info, + self.rtcp_mux, + self.comedia, self.enable_srtp, + self.srtp_crypto_suite, ) } } - /// Builder for serializing an instance of the [PipeTransportOptions] type. + /// Builder for serializing an instance of the [PlainTransportOptions] type. /// - /// Can be created using the [PipeTransportOptions::builder] method. + /// Can be created using the [PlainTransportOptions::builder] method. #[derive(Debug)] #[must_use] - pub struct PipeTransportOptionsBuilder(State); + pub struct PlainTransportOptionsBuilder(State); - impl PipeTransportOptionsBuilder<()> { - /// Setter for the [`base` field](PipeTransportOptions#structfield.base). + impl PlainTransportOptionsBuilder<()> { + /// Setter for the [`base` field](PlainTransportOptions#structfield.base). #[inline] #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> PipeTransportOptionsBuilder<(T0,)> + pub fn base(self, value: T0) -> PlainTransportOptionsBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - PipeTransportOptionsBuilder((value,)) + PlainTransportOptionsBuilder((value,)) } } - impl PipeTransportOptionsBuilder<(T0,)> { - /// Setter for the [`listen_info` field](PipeTransportOptions#structfield.listen_info). + impl PlainTransportOptionsBuilder<(T0,)> { + /// Setter for the [`listen_info` field](PlainTransportOptions#structfield.listen_info). #[inline] #[allow(clippy::type_complexity)] - pub fn listen_info(self, value: T1) -> PipeTransportOptionsBuilder<(T0, T1)> + pub fn listen_info(self, value: T1) -> PlainTransportOptionsBuilder<(T0, T1)> where T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - PipeTransportOptionsBuilder((v0, value)) + PlainTransportOptionsBuilder((v0, value)) } } - impl PipeTransportOptionsBuilder<(T0, T1)> { - /// Setter for the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx). + impl PlainTransportOptionsBuilder<(T0, T1)> { + /// Setter for the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info). #[inline] #[allow(clippy::type_complexity)] - pub fn enable_rtx(self, value: T2) -> PipeTransportOptionsBuilder<(T0, T1, T2)> + pub fn rtcp_listen_info( + self, + value: T2, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2)> where - T2: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptional<::planus::Offset>, { let (v0, v1) = self.0; - PipeTransportOptionsBuilder((v0, v1, value)) + PlainTransportOptionsBuilder((v0, v1, value)) } - /// Sets the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx) to the default value. + /// Sets the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn enable_rtx_as_default( + pub fn rtcp_listen_info_as_null( self, - ) -> PipeTransportOptionsBuilder<(T0, T1, ::planus::DefaultValue)> { - self.enable_rtx(::planus::DefaultValue) + ) -> PlainTransportOptionsBuilder<(T0, T1, ())> { + self.rtcp_listen_info(()) } } - impl PipeTransportOptionsBuilder<(T0, T1, T2)> { - /// Setter for the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp). + impl PlainTransportOptionsBuilder<(T0, T1, T2)> { + /// Setter for the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux). #[inline] #[allow(clippy::type_complexity)] - pub fn enable_srtp( + pub fn rtcp_mux( self, value: T3, - ) -> PipeTransportOptionsBuilder<(T0, T1, T2, T3)> + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3)> where T3: ::planus::WriteAsDefault, { let (v0, v1, v2) = self.0; - PipeTransportOptionsBuilder((v0, v1, v2, value)) + PlainTransportOptionsBuilder((v0, v1, v2, value)) } - /// Sets the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp) to the default value. + /// Sets the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_mux_as_default( + self, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, ::planus::DefaultValue)> + { + self.rtcp_mux(::planus::DefaultValue) + } + } + + impl PlainTransportOptionsBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`comedia` field](PlainTransportOptions#structfield.comedia). + #[inline] + #[allow(clippy::type_complexity)] + pub fn comedia( + self, + value: T4, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3) = self.0; + PlainTransportOptionsBuilder((v0, v1, v2, v3, value)) + } + + /// Sets the [`comedia` field](PlainTransportOptions#structfield.comedia) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn comedia_as_default( + self, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> + { + self.comedia(::planus::DefaultValue) + } + } + + impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp). + #[inline] + #[allow(clippy::type_complexity)] + pub fn enable_srtp( + self, + value: T5, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAsDefault, + { + let (v0, v1, v2, v3, v4) = self.0; + PlainTransportOptionsBuilder((v0, v1, v2, v3, v4, value)) + } + + /// Sets the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp) to the default value. #[inline] #[allow(clippy::type_complexity)] pub fn enable_srtp_as_default( self, - ) -> PipeTransportOptionsBuilder<(T0, T1, T2, ::planus::DefaultValue)> + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)> { self.enable_srtp(::planus::DefaultValue) } } - impl PipeTransportOptionsBuilder<(T0, T1, T2, T3)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PipeTransportOptions]. + impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5)> { + /// Setter for the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_crypto_suite( + self, + value: T6, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> + where + T6: ::planus::WriteAsOptional, + { + let (v0, v1, v2, v3, v4, v5) = self.0; + PlainTransportOptionsBuilder((v0, v1, v2, v3, v4, v5, value)) + } + + /// Sets the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_crypto_suite_as_null( + self, + ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, ())> { + self.srtp_crypto_suite(()) + } + } + + impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PlainTransportOptions]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -69408,18 +71547,21 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptional<::planus::Offset>, T3: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> - for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, + > ::planus::WriteAs<::planus::Offset> + for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } @@ -69427,18 +71569,21 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptional<::planus::Offset>, T3: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> - for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, + > ::planus::WriteAsOptional<::planus::Offset> + for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } @@ -69447,76 +71592,120 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, + T2: ::planus::WriteAsOptional<::planus::Offset>, T3: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset - for PipeTransportOptionsBuilder<(T0, T1, T2, T3)> + T4: ::planus::WriteAsDefault, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, + > ::planus::WriteAsOffset + for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - PipeTransportOptions::create(builder, v0, v1, v2, v3) + ) -> ::planus::Offset { + let (v0, v1, v2, v3, v4, v5, v6) = &self.0; + PlainTransportOptions::create(builder, v0, v1, v2, v3, v4, v5, v6) } } - /// Reference to a deserialized [PipeTransportOptions]. + /// Reference to a deserialized [PlainTransportOptions]. #[derive(Copy, Clone)] - pub struct PipeTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); + pub struct PlainTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> PipeTransportOptionsRef<'a> { - /// Getter for the [`base` field](PipeTransportOptions#structfield.base). + impl<'a> PlainTransportOptionsRef<'a> { + /// Getter for the [`base` field](PlainTransportOptions#structfield.base). #[inline] pub fn base(&self) -> ::planus::Result> { - self.0.access_required(0, "PipeTransportOptions", "base") + self.0.access_required(0, "PlainTransportOptions", "base") } - /// Getter for the [`listen_info` field](PipeTransportOptions#structfield.listen_info). + /// Getter for the [`listen_info` field](PlainTransportOptions#structfield.listen_info). #[inline] pub fn listen_info(&self) -> ::planus::Result> { self.0 - .access_required(1, "PipeTransportOptions", "listen_info") + .access_required(1, "PlainTransportOptions", "listen_info") } - /// Getter for the [`enable_rtx` field](PipeTransportOptions#structfield.enable_rtx). + /// Getter for the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info). #[inline] - pub fn enable_rtx(&self) -> ::planus::Result { + pub fn rtcp_listen_info( + &self, + ) -> ::planus::Result<::core::option::Option>> + { + self.0 + .access(2, "PlainTransportOptions", "rtcp_listen_info") + } + + /// Getter for the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux). + #[inline] + pub fn rtcp_mux(&self) -> ::planus::Result { ::core::result::Result::Ok( self.0 - .access(2, "PipeTransportOptions", "enable_rtx")? + .access(3, "PlainTransportOptions", "rtcp_mux")? .unwrap_or(false), ) } - /// Getter for the [`enable_srtp` field](PipeTransportOptions#structfield.enable_srtp). + /// Getter for the [`comedia` field](PlainTransportOptions#structfield.comedia). + #[inline] + pub fn comedia(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(4, "PlainTransportOptions", "comedia")? + .unwrap_or(false), + ) + } + + /// Getter for the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp). #[inline] pub fn enable_srtp(&self) -> ::planus::Result { ::core::result::Result::Ok( self.0 - .access(3, "PipeTransportOptions", "enable_srtp")? + .access(5, "PlainTransportOptions", "enable_srtp")? .unwrap_or(false), ) } + + /// Getter for the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite). + #[inline] + pub fn srtp_crypto_suite( + &self, + ) -> ::planus::Result<::core::option::Option> + { + self.0 + .access(6, "PlainTransportOptions", "srtp_crypto_suite") + } } - impl<'a> ::core::fmt::Debug for PipeTransportOptionsRef<'a> { + impl<'a> ::core::fmt::Debug for PlainTransportOptionsRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("PipeTransportOptionsRef"); + let mut f = f.debug_struct("PlainTransportOptionsRef"); f.field("base", &self.base()); f.field("listen_info", &self.listen_info()); - f.field("enable_rtx", &self.enable_rtx()); + if let ::core::option::Option::Some(field_rtcp_listen_info) = + self.rtcp_listen_info().transpose() + { + f.field("rtcp_listen_info", &field_rtcp_listen_info); + } + f.field("rtcp_mux", &self.rtcp_mux()); + f.field("comedia", &self.comedia()); f.field("enable_srtp", &self.enable_srtp()); + if let ::core::option::Option::Some(field_srtp_crypto_suite) = + self.srtp_crypto_suite().transpose() + { + f.field("srtp_crypto_suite", &field_srtp_crypto_suite); + } f.finish() } } - impl<'a> ::core::convert::TryFrom> for PipeTransportOptions { + impl<'a> ::core::convert::TryFrom> for PlainTransportOptions { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: PipeTransportOptionsRef<'a>) -> ::planus::Result { + fn try_from(value: PlainTransportOptionsRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( value.base()?, @@ -69524,13 +71713,32 @@ mod root { listen_info: ::planus::alloc::boxed::Box::new( ::core::convert::TryInto::try_into(value.listen_info()?)?, ), - enable_rtx: ::core::convert::TryInto::try_into(value.enable_rtx()?)?, + rtcp_listen_info: if let ::core::option::Option::Some(rtcp_listen_info) = + value.rtcp_listen_info()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(rtcp_listen_info)?, + )) + } else { + ::core::option::Option::None + }, + rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, + comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, enable_srtp: ::core::convert::TryInto::try_into(value.enable_srtp()?)?, + srtp_crypto_suite: if let ::core::option::Option::Some(srtp_crypto_suite) = + value.srtp_crypto_suite()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + srtp_crypto_suite, + )?) + } else { + ::core::option::Option::None + }, }) } } - impl<'a> ::planus::TableRead<'a> for PipeTransportOptionsRef<'a> { + impl<'a> ::planus::TableRead<'a> for PlainTransportOptionsRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -69542,7 +71750,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for PipeTransportOptionsRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for PlainTransportOptionsRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -69552,7 +71760,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[PipeTransportOptionsRef]", + "[PlainTransportOptionsRef]", "get", buffer.offset_from_start, ) @@ -69560,8 +71768,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for PipeTransportOptions { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for PlainTransportOptions { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -69570,7 +71778,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -69585,7 +71793,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for PipeTransportOptionsRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for PlainTransportOptionsRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -69596,7 +71804,7 @@ mod root { ) .map_err(|error_kind| { error_kind.with_error_location( - "[PipeTransportOptionsRef]", + "[PlainTransportOptionsRef]", "read_as_root", 0, ) @@ -69604,10 +71812,10 @@ mod root { } } - /// The table `ConnectRequest` in the namespace `FBS.PipeTransport` + /// The table `ConnectRequest` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `ConnectRequest` in the file `../worker/fbs/pipeTransport.fbs:12` + /// * Table `ConnectRequest` in the file `../worker/fbs/plainTransport.fbs:17` #[derive( Clone, Debug, @@ -69621,15 +71829,29 @@ mod root { )] pub struct ConnectRequest { /// The field `ip` in the table `ConnectRequest` - pub ip: ::planus::alloc::string::String, + pub ip: ::core::option::Option<::planus::alloc::string::String>, /// The field `port` in the table `ConnectRequest` pub port: ::core::option::Option, + /// The field `rtcp_port` in the table `ConnectRequest` + pub rtcp_port: ::core::option::Option, /// The field `srtp_parameters` in the table `ConnectRequest` pub srtp_parameters: ::core::option::Option< - ::planus::alloc::boxed::Box, + ::planus::alloc::boxed::Box, >, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for ConnectRequest { + fn default() -> Self { + Self { + ip: ::core::default::Default::default(), + port: ::core::default::Default::default(), + rtcp_port: ::core::default::Default::default(), + srtp_parameters: ::core::default::Default::default(), + } + } + } + impl ConnectRequest { /// Creates a [ConnectRequestBuilder] for serializing an instance of this table. #[inline] @@ -69640,30 +71862,38 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ip: impl ::planus::WriteAs<::planus::Offset>, + field_ip: impl ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, field_port: impl ::planus::WriteAsOptional, + field_rtcp_port: impl ::planus::WriteAsOptional, field_srtp_parameters: impl ::planus::WriteAsOptional< - ::planus::Offset, + ::planus::Offset, >, ) -> ::planus::Offset { let prepared_ip = field_ip.prepare(builder); let prepared_port = field_port.prepare(builder); + let prepared_rtcp_port = field_rtcp_port.prepare(builder); let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<12> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + if prepared_ip.is_some() { + table_writer.write_entry::<::planus::Offset>(0); + } if prepared_srtp_parameters.is_some() { - table_writer - .write_entry::<::planus::Offset>(2); + table_writer.write_entry::<::planus::Offset>(3); } if prepared_port.is_some() { table_writer.write_entry::(1); } + if prepared_rtcp_port.is_some() { + table_writer.write_entry::(2); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_ip); + if let ::core::option::Option::Some(prepared_ip) = prepared_ip { + object_writer.write::<_, _, 4>(&prepared_ip); + } if let ::core::option::Option::Some(prepared_srtp_parameters) = prepared_srtp_parameters { @@ -69672,6 +71902,11 @@ mod root { if let ::core::option::Option::Some(prepared_port) = prepared_port { object_writer.write::<_, _, 2>(&prepared_port); } + if let ::core::option::Option::Some(prepared_rtcp_port) = + prepared_rtcp_port + { + object_writer.write::<_, _, 2>(&prepared_rtcp_port); + } }); } builder.current_offset() @@ -69708,7 +71943,13 @@ mod root { &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - ConnectRequest::create(builder, &self.ip, self.port, &self.srtp_parameters) + ConnectRequest::create( + builder, + &self.ip, + self.port, + self.rtcp_port, + &self.srtp_parameters, + ) } } @@ -69725,10 +71966,17 @@ mod root { #[allow(clippy::type_complexity)] pub fn ip(self, value: T0) -> ConnectRequestBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, { ConnectRequestBuilder((value,)) } + + /// Sets the [`ip` field](ConnectRequest#structfield.ip) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ip_as_null(self) -> ConnectRequestBuilder<((),)> { + self.ip(()) + } } impl ConnectRequestBuilder<(T0,)> { @@ -69752,28 +72000,51 @@ mod root { } impl ConnectRequestBuilder<(T0, T1)> { - /// Setter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + /// Setter for the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters(self, value: T2) -> ConnectRequestBuilder<(T0, T1, T2)> + pub fn rtcp_port(self, value: T2) -> ConnectRequestBuilder<(T0, T1, T2)> where - T2: ::planus::WriteAsOptional< - ::planus::Offset, - >, + T2: ::planus::WriteAsOptional, { let (v0, v1) = self.0; ConnectRequestBuilder((v0, v1, value)) } + /// Sets the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_port_as_null(self) -> ConnectRequestBuilder<(T0, T1, ())> { + self.rtcp_port(()) + } + } + + impl ConnectRequestBuilder<(T0, T1, T2)> { + /// Setter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters( + self, + value: T3, + ) -> ConnectRequestBuilder<(T0, T1, T2, T3)> + where + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + { + let (v0, v1, v2) = self.0; + ConnectRequestBuilder((v0, v1, v2, value)) + } + /// Sets the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters_as_null(self) -> ConnectRequestBuilder<(T0, T1, ())> { + pub fn srtp_parameters_as_null(self) -> ConnectRequestBuilder<(T0, T1, T2, ())> { self.srtp_parameters(()) } } - impl ConnectRequestBuilder<(T0, T1, T2)> { + impl ConnectRequestBuilder<(T0, T1, T2, T3)> { /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectRequest]. #[inline] pub fn finish( @@ -69788,11 +72059,14 @@ mod root { } impl< - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional<::planus::Offset>, + T2: ::planus::WriteAsOptional, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, > ::planus::WriteAs<::planus::Offset> - for ConnectRequestBuilder<(T0, T1, T2)> + for ConnectRequestBuilder<(T0, T1, T2, T3)> { type Prepared = ::planus::Offset; @@ -69806,11 +72080,14 @@ mod root { } impl< - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional<::planus::Offset>, + T2: ::planus::WriteAsOptional, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, > ::planus::WriteAsOptional<::planus::Offset> - for ConnectRequestBuilder<(T0, T1, T2)> + for ConnectRequestBuilder<(T0, T1, T2, T3)> { type Prepared = ::planus::Offset; @@ -69824,18 +72101,22 @@ mod root { } impl< - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset for ConnectRequestBuilder<(T0, T1, T2)> + T2: ::planus::WriteAsOptional, + T3: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for ConnectRequestBuilder<(T0, T1, T2, T3)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - ConnectRequest::create(builder, v0, v1, v2) + let (v0, v1, v2, v3) = &self.0; + ConnectRequest::create(builder, v0, v1, v2, v3) } } @@ -69846,8 +72127,11 @@ mod root { impl<'a> ConnectRequestRef<'a> { /// Getter for the [`ip` field](ConnectRequest#structfield.ip). #[inline] - pub fn ip(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "ConnectRequest", "ip") + pub fn ip( + &self, + ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> + { + self.0.access(0, "ConnectRequest", "ip") } /// Getter for the [`port` field](ConnectRequest#structfield.port). @@ -69856,23 +72140,37 @@ mod root { self.0.access(1, "ConnectRequest", "port") } + /// Getter for the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port). + #[inline] + pub fn rtcp_port(&self) -> ::planus::Result<::core::option::Option> { + self.0.access(2, "ConnectRequest", "rtcp_port") + } + /// Getter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). #[inline] pub fn srtp_parameters( &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(2, "ConnectRequest", "srtp_parameters") + ) -> ::planus::Result< + ::core::option::Option>, + > { + self.0.access(3, "ConnectRequest", "srtp_parameters") } } impl<'a> ::core::fmt::Debug for ConnectRequestRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("ConnectRequestRef"); - f.field("ip", &self.ip()); + if let ::core::option::Option::Some(field_ip) = self.ip().transpose() { + f.field("ip", &field_ip); + } if let ::core::option::Option::Some(field_port) = self.port().transpose() { f.field("port", &field_port); } + if let ::core::option::Option::Some(field_rtcp_port) = + self.rtcp_port().transpose() + { + f.field("rtcp_port", &field_rtcp_port); + } if let ::core::option::Option::Some(field_srtp_parameters) = self.srtp_parameters().transpose() { @@ -69888,12 +72186,25 @@ mod root { #[allow(unreachable_code)] fn try_from(value: ConnectRequestRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ip: ::core::convert::TryInto::try_into(value.ip()?)?, + ip: if let ::core::option::Option::Some(ip) = value.ip()? { + ::core::option::Option::Some(::core::convert::TryInto::try_into(ip)?) + } else { + ::core::option::Option::None + }, port: if let ::core::option::Option::Some(port) = value.port()? { ::core::option::Option::Some(::core::convert::TryInto::try_into(port)?) } else { ::core::option::Option::None }, + rtcp_port: if let ::core::option::Option::Some(rtcp_port) = + value.rtcp_port()? + { + ::core::option::Option::Some(::core::convert::TryInto::try_into( + rtcp_port, + )?) + } else { + ::core::option::Option::None + }, srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = value.srtp_parameters()? { @@ -69977,10 +72288,10 @@ mod root { } } - /// The table `ConnectResponse` in the namespace `FBS.PipeTransport` + /// The table `ConnectResponse` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `ConnectResponse` in the file `../worker/fbs/pipeTransport.fbs:18` + /// * Table `ConnectResponse` in the file `../worker/fbs/plainTransport.fbs:24` #[derive( Clone, Debug, @@ -69994,17 +72305,14 @@ mod root { )] pub struct ConnectResponse { /// The field `tuple` in the table `ConnectResponse` - pub tuple: + pub tuple: ::planus::alloc::boxed::Box, + /// The field `rtcp_tuple` in the table `ConnectResponse` + pub rtcp_tuple: ::core::option::Option<::planus::alloc::boxed::Box>, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for ConnectResponse { - fn default() -> Self { - Self { - tuple: ::core::default::Default::default(), - } - } + /// The field `srtp_parameters` in the table `ConnectResponse` + pub srtp_parameters: ::core::option::Option< + ::planus::alloc::boxed::Box, + >, } impl ConnectResponse { @@ -70017,22 +72325,40 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_tuple: impl ::planus::WriteAsOptional< + field_tuple: impl ::planus::WriteAs<::planus::Offset>, + field_rtcp_tuple: impl ::planus::WriteAsOptional< ::planus::Offset, >, + field_srtp_parameters: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, ) -> ::planus::Offset { let prepared_tuple = field_tuple.prepare(builder); + let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); + let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<10> = ::core::default::Default::default(); - if prepared_tuple.is_some() { - table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(0); + if prepared_rtcp_tuple.is_some() { + table_writer.write_entry::<::planus::Offset>(1); + } + if prepared_srtp_parameters.is_some() { + table_writer.write_entry::<::planus::Offset>(2); } unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_tuple) = prepared_tuple { - object_writer.write::<_, _, 4>(&prepared_tuple); + object_writer.write::<_, _, 4>(&prepared_tuple); + if let ::core::option::Option::Some(prepared_rtcp_tuple) = + prepared_rtcp_tuple + { + object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); + } + if let ::core::option::Option::Some(prepared_srtp_parameters) = + prepared_srtp_parameters + { + object_writer.write::<_, _, 4>(&prepared_srtp_parameters); } }); } @@ -70070,7 +72396,12 @@ mod root { &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - ConnectResponse::create(builder, &self.tuple) + ConnectResponse::create( + builder, + &self.tuple, + &self.rtcp_tuple, + &self.srtp_parameters, + ) } } @@ -70087,20 +72418,55 @@ mod root { #[allow(clippy::type_complexity)] pub fn tuple(self, value: T0) -> ConnectResponseBuilder<(T0,)> where - T0: ::planus::WriteAsOptional<::planus::Offset>, + T0: ::planus::WriteAs<::planus::Offset>, { ConnectResponseBuilder((value,)) } + } + + impl ConnectResponseBuilder<(T0,)> { + /// Setter for the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_tuple(self, value: T1) -> ConnectResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAsOptional<::planus::Offset>, + { + let (v0,) = self.0; + ConnectResponseBuilder((v0, value)) + } - /// Sets the [`tuple` field](ConnectResponse#structfield.tuple) to null. + /// Sets the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn tuple_as_null(self) -> ConnectResponseBuilder<((),)> { - self.tuple(()) + pub fn rtcp_tuple_as_null(self) -> ConnectResponseBuilder<(T0, ())> { + self.rtcp_tuple(()) } } - impl ConnectResponseBuilder<(T0,)> { + impl ConnectResponseBuilder<(T0, T1)> { + /// Setter for the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters(self, value: T2) -> ConnectResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + { + let (v0, v1) = self.0; + ConnectResponseBuilder((v0, v1, value)) + } + + /// Sets the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters_as_null(self) -> ConnectResponseBuilder<(T0, T1, ())> { + self.srtp_parameters(()) + } + } + + impl ConnectResponseBuilder<(T0, T1, T2)> { /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectResponse]. #[inline] pub fn finish( @@ -70114,9 +72480,14 @@ mod root { } } - impl>> - ::planus::WriteAs<::planus::Offset> - for ConnectResponseBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional<::planus::Offset>, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAs<::planus::Offset> + for ConnectResponseBuilder<(T0, T1, T2)> { type Prepared = ::planus::Offset; @@ -70129,9 +72500,14 @@ mod root { } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for ConnectResponseBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional<::planus::Offset>, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for ConnectResponseBuilder<(T0, T1, T2)> { type Prepared = ::planus::Offset; @@ -70144,16 +72520,22 @@ mod root { } } - impl>> - ::planus::WriteAsOffset for ConnectResponseBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsOptional<::planus::Offset>, + T2: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for ConnectResponseBuilder<(T0, T1, T2)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - let (v0,) = &self.0; - ConnectResponse::create(builder, v0) + let (v0, v1, v2) = &self.0; + ConnectResponse::create(builder, v0, v1, v2) } } @@ -70164,19 +72546,43 @@ mod root { impl<'a> ConnectResponseRef<'a> { /// Getter for the [`tuple` field](ConnectResponse#structfield.tuple). #[inline] - pub fn tuple( + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(0, "ConnectResponse", "tuple") + } + + /// Getter for the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple). + #[inline] + pub fn rtcp_tuple( &self, ) -> ::planus::Result<::core::option::Option>> { - self.0.access(0, "ConnectResponse", "tuple") + self.0.access(1, "ConnectResponse", "rtcp_tuple") + } + + /// Getter for the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters). + #[inline] + pub fn srtp_parameters( + &self, + ) -> ::planus::Result< + ::core::option::Option>, + > { + self.0.access(2, "ConnectResponse", "srtp_parameters") } } impl<'a> ::core::fmt::Debug for ConnectResponseRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("ConnectResponseRef"); - if let ::core::option::Option::Some(field_tuple) = self.tuple().transpose() { - f.field("tuple", &field_tuple); + f.field("tuple", &self.tuple()); + if let ::core::option::Option::Some(field_rtcp_tuple) = + self.rtcp_tuple().transpose() + { + f.field("rtcp_tuple", &field_rtcp_tuple); + } + if let ::core::option::Option::Some(field_srtp_parameters) = + self.srtp_parameters().transpose() + { + f.field("srtp_parameters", &field_srtp_parameters); } f.finish() } @@ -70188,9 +72594,23 @@ mod root { #[allow(unreachable_code)] fn try_from(value: ConnectResponseRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - tuple: if let ::core::option::Option::Some(tuple) = value.tuple()? { + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, + ), + rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = + value.rtcp_tuple()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(rtcp_tuple)?, + )) + } else { + ::core::option::Option::None + }, + srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = + value.srtp_parameters()? + { ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(tuple)?, + ::core::convert::TryInto::try_into(srtp_parameters)?, )) } else { ::core::option::Option::None @@ -70269,10 +72689,10 @@ mod root { } } - /// The table `DumpResponse` in the namespace `FBS.PipeTransport` + /// The table `DumpResponse` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/pipeTransport.fbs:22` + /// * Table `DumpResponse` in the file `../worker/fbs/plainTransport.fbs:30` #[derive( Clone, Debug, @@ -70287,13 +72707,18 @@ mod root { pub struct DumpResponse { /// The field `base` in the table `DumpResponse` pub base: ::planus::alloc::boxed::Box, + /// The field `rtcp_mux` in the table `DumpResponse` + pub rtcp_mux: bool, + /// The field `comedia` in the table `DumpResponse` + pub comedia: bool, /// The field `tuple` in the table `DumpResponse` pub tuple: ::planus::alloc::boxed::Box, - /// The field `rtx` in the table `DumpResponse` - pub rtx: bool, + /// The field `rtcp_tuple` in the table `DumpResponse` + pub rtcp_tuple: + ::core::option::Option<::planus::alloc::boxed::Box>, /// The field `srtp_parameters` in the table `DumpResponse` pub srtp_parameters: ::core::option::Option< - ::planus::alloc::boxed::Box, + ::planus::alloc::boxed::Box, >, } @@ -70308,26 +72733,37 @@ mod root { pub fn create( builder: &mut ::planus::Builder, field_base: impl ::planus::WriteAs<::planus::Offset>, + field_rtcp_mux: impl ::planus::WriteAsDefault, + field_comedia: impl ::planus::WriteAsDefault, field_tuple: impl ::planus::WriteAs<::planus::Offset>, - field_rtx: impl ::planus::WriteAsDefault, + field_rtcp_tuple: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, field_srtp_parameters: impl ::planus::WriteAsOptional< - ::planus::Offset, + ::planus::Offset, >, ) -> ::planus::Offset { let prepared_base = field_base.prepare(builder); + let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); + let prepared_comedia = field_comedia.prepare(builder, &false); let prepared_tuple = field_tuple.prepare(builder); - let prepared_rtx = field_rtx.prepare(builder, &false); + let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<12> = + let mut table_writer: ::planus::table_writer::TableWriter<16> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); + table_writer.write_entry::<::planus::Offset>(3); + if prepared_rtcp_tuple.is_some() { + table_writer.write_entry::<::planus::Offset>(4); + } if prepared_srtp_parameters.is_some() { - table_writer - .write_entry::<::planus::Offset>(3); + table_writer.write_entry::<::planus::Offset>(5); } - if prepared_rtx.is_some() { + if prepared_rtcp_mux.is_some() { + table_writer.write_entry::(1); + } + if prepared_comedia.is_some() { table_writer.write_entry::(2); } @@ -70335,13 +72771,24 @@ mod root { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_base); object_writer.write::<_, _, 4>(&prepared_tuple); + if let ::core::option::Option::Some(prepared_rtcp_tuple) = + prepared_rtcp_tuple + { + object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); + } if let ::core::option::Option::Some(prepared_srtp_parameters) = prepared_srtp_parameters { object_writer.write::<_, _, 4>(&prepared_srtp_parameters); } - if let ::core::option::Option::Some(prepared_rtx) = prepared_rtx { - object_writer.write::<_, _, 1>(&prepared_rtx); + if let ::core::option::Option::Some(prepared_rtcp_mux) = + prepared_rtcp_mux + { + object_writer.write::<_, _, 1>(&prepared_rtcp_mux); + } + if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia + { + object_writer.write::<_, _, 1>(&prepared_comedia); } }); } @@ -70382,8 +72829,10 @@ mod root { DumpResponse::create( builder, &self.base, + self.rtcp_mux, + self.comedia, &self.tuple, - self.rtx, + &self.rtcp_tuple, &self.srtp_parameters, ) } @@ -70409,23 +72858,32 @@ mod root { } impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`tuple` field](DumpResponse#structfield.tuple). + /// Setter for the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux). #[inline] #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T1) -> DumpResponseBuilder<(T0, T1)> + pub fn rtcp_mux(self, value: T1) -> DumpResponseBuilder<(T0, T1)> where - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, { let (v0,) = self.0; DumpResponseBuilder((v0, value)) } + + /// Sets the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_mux_as_default( + self, + ) -> DumpResponseBuilder<(T0, ::planus::DefaultValue)> { + self.rtcp_mux(::planus::DefaultValue) + } } impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`rtx` field](DumpResponse#structfield.rtx). + /// Setter for the [`comedia` field](DumpResponse#structfield.comedia). #[inline] #[allow(clippy::type_complexity)] - pub fn rtx(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> + pub fn comedia(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> where T2: ::planus::WriteAsDefault, { @@ -70433,39 +72891,77 @@ mod root { DumpResponseBuilder((v0, v1, value)) } - /// Sets the [`rtx` field](DumpResponse#structfield.rtx) to the default value. + /// Sets the [`comedia` field](DumpResponse#structfield.comedia) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn rtx_as_default( + pub fn comedia_as_default( self, ) -> DumpResponseBuilder<(T0, T1, ::planus::DefaultValue)> { - self.rtx(::planus::DefaultValue) + self.comedia(::planus::DefaultValue) } } impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + /// Setter for the [`tuple` field](DumpResponse#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> + pub fn tuple(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> where - T3: ::planus::WriteAsOptional< - ::planus::Offset, - >, + T3: ::planus::WriteAs<::planus::Offset>, { let (v0, v1, v2) = self.0; DumpResponseBuilder((v0, v1, v2, value)) } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_tuple(self, value: T4) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> + where + T4: ::planus::WriteAsOptional<::planus::Offset>, + { + let (v0, v1, v2, v3) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, value)) + } + + /// Sets the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_tuple_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, T3, ())> { + self.rtcp_tuple(()) + } + } + + impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { + /// Setter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + #[inline] + #[allow(clippy::type_complexity)] + pub fn srtp_parameters( + self, + value: T5, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + where + T5: ::planus::WriteAsOptional< + ::planus::Offset, + >, + { + let (v0, v1, v2, v3, v4) = self.0; + DumpResponseBuilder((v0, v1, v2, v3, v4, value)) + } /// Sets the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters) to null. #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, ())> { + pub fn srtp_parameters_as_null( + self, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, ())> { self.srtp_parameters(()) } } - impl DumpResponseBuilder<(T0, T1, T2, T3)> { + impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. #[inline] pub fn finish( @@ -70481,11 +72977,15 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptional<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset, + >, > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3)> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { type Prepared = ::planus::Offset; @@ -70500,11 +73000,15 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptional<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset, + >, > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3)> + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { type Prepared = ::planus::Offset; @@ -70519,18 +73023,23 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset for DumpResponseBuilder<(T0, T1, T2, T3)> + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, + T5: ::planus::WriteAsOptional< + ::planus::Offset, + >, + > ::planus::WriteAsOffset + for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3) + let (v0, v1, v2, v3, v4, v5) = &self.0; + DumpResponse::create(builder, v0, v1, v2, v3, v4, v5) } } @@ -70545,27 +73054,49 @@ mod root { self.0.access_required(0, "DumpResponse", "base") } - /// Getter for the [`tuple` field](DumpResponse#structfield.tuple). + /// Getter for the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux). #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(1, "DumpResponse", "tuple") + pub fn rtcp_mux(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "DumpResponse", "rtcp_mux")? + .unwrap_or(false), + ) } - /// Getter for the [`rtx` field](DumpResponse#structfield.rtx). + /// Getter for the [`comedia` field](DumpResponse#structfield.comedia). #[inline] - pub fn rtx(&self) -> ::planus::Result { + pub fn comedia(&self) -> ::planus::Result { ::core::result::Result::Ok( - self.0.access(2, "DumpResponse", "rtx")?.unwrap_or(false), + self.0 + .access(2, "DumpResponse", "comedia")? + .unwrap_or(false), ) } + /// Getter for the [`tuple` field](DumpResponse#structfield.tuple). + #[inline] + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(3, "DumpResponse", "tuple") + } + + /// Getter for the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple). + #[inline] + pub fn rtcp_tuple( + &self, + ) -> ::planus::Result<::core::option::Option>> + { + self.0.access(4, "DumpResponse", "rtcp_tuple") + } + /// Getter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). #[inline] pub fn srtp_parameters( &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(3, "DumpResponse", "srtp_parameters") + ) -> ::planus::Result< + ::core::option::Option>, + > { + self.0.access(5, "DumpResponse", "srtp_parameters") } } @@ -70573,8 +73104,14 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("DumpResponseRef"); f.field("base", &self.base()); + f.field("rtcp_mux", &self.rtcp_mux()); + f.field("comedia", &self.comedia()); f.field("tuple", &self.tuple()); - f.field("rtx", &self.rtx()); + if let ::core::option::Option::Some(field_rtcp_tuple) = + self.rtcp_tuple().transpose() + { + f.field("rtcp_tuple", &field_rtcp_tuple); + } if let ::core::option::Option::Some(field_srtp_parameters) = self.srtp_parameters().transpose() { @@ -70593,10 +73130,20 @@ mod root { base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( value.base()?, )?), + rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, + comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, tuple: ::planus::alloc::boxed::Box::new( ::core::convert::TryInto::try_into(value.tuple()?)?, ), - rtx: ::core::convert::TryInto::try_into(value.rtx()?)?, + rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = + value.rtcp_tuple()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(rtcp_tuple)?, + )) + } else { + ::core::option::Option::None + }, srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = value.srtp_parameters()? { @@ -70680,18 +73227,25 @@ mod root { } } - /// The table `GetStatsResponse` in the namespace `FBS.PipeTransport` + /// The table `GetStatsResponse` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `GetStatsResponse` in the file `../worker/fbs/pipeTransport.fbs:29` + /// * Table `GetStatsResponse` in the file `../worker/fbs/plainTransport.fbs:39` #[derive( Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] pub struct GetStatsResponse { /// The field `base` in the table `GetStatsResponse` pub base: ::planus::alloc::boxed::Box, + /// The field `rtcp_mux` in the table `GetStatsResponse` + pub rtcp_mux: bool, + /// The field `comedia` in the table `GetStatsResponse` + pub comedia: bool, /// The field `tuple` in the table `GetStatsResponse` pub tuple: ::planus::alloc::boxed::Box, + /// The field `rtcp_tuple` in the table `GetStatsResponse` + pub rtcp_tuple: + ::core::option::Option<::planus::alloc::boxed::Box>, } impl GetStatsResponse { @@ -70705,20 +73259,51 @@ mod root { pub fn create( builder: &mut ::planus::Builder, field_base: impl ::planus::WriteAs<::planus::Offset>, + field_rtcp_mux: impl ::planus::WriteAsDefault, + field_comedia: impl ::planus::WriteAsDefault, field_tuple: impl ::planus::WriteAs<::planus::Offset>, + field_rtcp_tuple: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, ) -> ::planus::Offset { let prepared_base = field_base.prepare(builder); + let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); + let prepared_comedia = field_comedia.prepare(builder, &false); let prepared_tuple = field_tuple.prepare(builder); + let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<14> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); + table_writer.write_entry::<::planus::Offset>(3); + if prepared_rtcp_tuple.is_some() { + table_writer.write_entry::<::planus::Offset>(4); + } + if prepared_rtcp_mux.is_some() { + table_writer.write_entry::(1); + } + if prepared_comedia.is_some() { + table_writer.write_entry::(2); + } unsafe { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_base); object_writer.write::<_, _, 4>(&prepared_tuple); + if let ::core::option::Option::Some(prepared_rtcp_tuple) = + prepared_rtcp_tuple + { + object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); + } + if let ::core::option::Option::Some(prepared_rtcp_mux) = + prepared_rtcp_mux + { + object_writer.write::<_, _, 1>(&prepared_rtcp_mux); + } + if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia + { + object_writer.write::<_, _, 1>(&prepared_comedia); + } }); } builder.current_offset() @@ -70751,47 +73336,121 @@ mod root { impl ::planus::WriteAsOffset for GetStatsResponse { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - GetStatsResponse::create(builder, &self.base, &self.tuple) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + GetStatsResponse::create( + builder, + &self.base, + self.rtcp_mux, + self.comedia, + &self.tuple, + &self.rtcp_tuple, + ) + } + } + + /// Builder for serializing an instance of the [GetStatsResponse] type. + /// + /// Can be created using the [GetStatsResponse::builder] method. + #[derive(Debug)] + #[must_use] + pub struct GetStatsResponseBuilder(State); + + impl GetStatsResponseBuilder<()> { + /// Setter for the [`base` field](GetStatsResponse#structfield.base). + #[inline] + #[allow(clippy::type_complexity)] + pub fn base(self, value: T0) -> GetStatsResponseBuilder<(T0,)> + where + T0: ::planus::WriteAs<::planus::Offset>, + { + GetStatsResponseBuilder((value,)) + } + } + + impl GetStatsResponseBuilder<(T0,)> { + /// Setter for the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux). + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_mux(self, value: T1) -> GetStatsResponseBuilder<(T0, T1)> + where + T1: ::planus::WriteAsDefault, + { + let (v0,) = self.0; + GetStatsResponseBuilder((v0, value)) + } + + /// Sets the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_mux_as_default( + self, + ) -> GetStatsResponseBuilder<(T0, ::planus::DefaultValue)> { + self.rtcp_mux(::planus::DefaultValue) + } + } + + impl GetStatsResponseBuilder<(T0, T1)> { + /// Setter for the [`comedia` field](GetStatsResponse#structfield.comedia). + #[inline] + #[allow(clippy::type_complexity)] + pub fn comedia(self, value: T2) -> GetStatsResponseBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsDefault, + { + let (v0, v1) = self.0; + GetStatsResponseBuilder((v0, v1, value)) + } + + /// Sets the [`comedia` field](GetStatsResponse#structfield.comedia) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn comedia_as_default( + self, + ) -> GetStatsResponseBuilder<(T0, T1, ::planus::DefaultValue)> { + self.comedia(::planus::DefaultValue) } } - /// Builder for serializing an instance of the [GetStatsResponse] type. - /// - /// Can be created using the [GetStatsResponse::builder] method. - #[derive(Debug)] - #[must_use] - pub struct GetStatsResponseBuilder(State); - - impl GetStatsResponseBuilder<()> { - /// Setter for the [`base` field](GetStatsResponse#structfield.base). + impl GetStatsResponseBuilder<(T0, T1, T2)> { + /// Setter for the [`tuple` field](GetStatsResponse#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> GetStatsResponseBuilder<(T0,)> + pub fn tuple(self, value: T3) -> GetStatsResponseBuilder<(T0, T1, T2, T3)> where - T0: ::planus::WriteAs<::planus::Offset>, + T3: ::planus::WriteAs<::planus::Offset>, { - GetStatsResponseBuilder((value,)) + let (v0, v1, v2) = self.0; + GetStatsResponseBuilder((v0, v1, v2, value)) } } - impl GetStatsResponseBuilder<(T0,)> { - /// Setter for the [`tuple` field](GetStatsResponse#structfield.tuple). + impl GetStatsResponseBuilder<(T0, T1, T2, T3)> { + /// Setter for the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T1) -> GetStatsResponseBuilder<(T0, T1)> + pub fn rtcp_tuple( + self, + value: T4, + ) -> GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> where - T1: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, { - let (v0,) = self.0; - GetStatsResponseBuilder((v0, value)) + let (v0, v1, v2, v3) = self.0; + GetStatsResponseBuilder((v0, v1, v2, v3, value)) + } + + /// Sets the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple) to null. + #[inline] + #[allow(clippy::type_complexity)] + pub fn rtcp_tuple_as_null(self) -> GetStatsResponseBuilder<(T0, T1, T2, T3, ())> { + self.rtcp_tuple(()) } } - impl GetStatsResponseBuilder<(T0, T1)> { + impl GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [GetStatsResponse]. #[inline] pub fn finish( @@ -70807,9 +73466,12 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, > ::planus::WriteAs<::planus::Offset> - for GetStatsResponseBuilder<(T0, T1)> + for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { type Prepared = ::planus::Offset; @@ -70824,9 +73486,12 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, > ::planus::WriteAsOptional<::planus::Offset> - for GetStatsResponseBuilder<(T0, T1)> + for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { type Prepared = ::planus::Offset; @@ -70841,16 +73506,20 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset for GetStatsResponseBuilder<(T0, T1)> + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, + T3: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsOptional<::planus::Offset>, + > ::planus::WriteAsOffset + for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - let (v0, v1) = &self.0; - GetStatsResponse::create(builder, v0, v1) + let (v0, v1, v2, v3, v4) = &self.0; + GetStatsResponse::create(builder, v0, v1, v2, v3, v4) } } @@ -70865,10 +73534,39 @@ mod root { self.0.access_required(0, "GetStatsResponse", "base") } + /// Getter for the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux). + #[inline] + pub fn rtcp_mux(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "GetStatsResponse", "rtcp_mux")? + .unwrap_or(false), + ) + } + + /// Getter for the [`comedia` field](GetStatsResponse#structfield.comedia). + #[inline] + pub fn comedia(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(2, "GetStatsResponse", "comedia")? + .unwrap_or(false), + ) + } + /// Getter for the [`tuple` field](GetStatsResponse#structfield.tuple). #[inline] pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(1, "GetStatsResponse", "tuple") + self.0.access_required(3, "GetStatsResponse", "tuple") + } + + /// Getter for the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple). + #[inline] + pub fn rtcp_tuple( + &self, + ) -> ::planus::Result<::core::option::Option>> + { + self.0.access(4, "GetStatsResponse", "rtcp_tuple") } } @@ -70876,7 +73574,14 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("GetStatsResponseRef"); f.field("base", &self.base()); + f.field("rtcp_mux", &self.rtcp_mux()); + f.field("comedia", &self.comedia()); f.field("tuple", &self.tuple()); + if let ::core::option::Option::Some(field_rtcp_tuple) = + self.rtcp_tuple().transpose() + { + f.field("rtcp_tuple", &field_rtcp_tuple); + } f.finish() } } @@ -70890,9 +73595,20 @@ mod root { base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( value.base()?, )?), + rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, + comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, tuple: ::planus::alloc::boxed::Box::new( ::core::convert::TryInto::try_into(value.tuple()?)?, ), + rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = + value.rtcp_tuple()? + { + ::core::option::Option::Some(::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(rtcp_tuple)?, + )) + } else { + ::core::option::Option::None + }, }) } } @@ -70966,16 +73682,11 @@ mod root { }) } } - } - /// The namespace `FBS.PlainTransport` - /// - /// Generated from these locations: - /// * File `../worker/fbs/plainTransport.fbs` - pub mod plain_transport { - /// The table `PlainTransportOptions` in the namespace `FBS.PlainTransport` + + /// The table `TupleNotification` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `PlainTransportOptions` in the file `../worker/fbs/plainTransport.fbs:6` + /// * Table `TupleNotification` in the file `../worker/fbs/plainTransport.fbs:49` #[derive( Clone, Debug, @@ -70987,525 +73698,182 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct PlainTransportOptions { - /// The field `base` in the table `PlainTransportOptions` - pub base: ::planus::alloc::boxed::Box, - /// The field `listen_info` in the table `PlainTransportOptions` - pub listen_info: ::planus::alloc::boxed::Box, - /// The field `rtcp_listen_info` in the table `PlainTransportOptions` - pub rtcp_listen_info: ::core::option::Option< - ::planus::alloc::boxed::Box, - >, - /// The field `rtcp_mux` in the table `PlainTransportOptions` - pub rtcp_mux: bool, - /// The field `comedia` in the table `PlainTransportOptions` - pub comedia: bool, - /// The field `enable_srtp` in the table `PlainTransportOptions` - pub enable_srtp: bool, - /// The field `srtp_crypto_suite` in the table `PlainTransportOptions` - pub srtp_crypto_suite: ::core::option::Option<::planus::alloc::string::String>, + pub struct TupleNotification { + /// The field `tuple` in the table `TupleNotification` + pub tuple: ::planus::alloc::boxed::Box, } - impl PlainTransportOptions { - /// Creates a [PlainTransportOptionsBuilder] for serializing an instance of this table. + impl TupleNotification { + /// Creates a [TupleNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> PlainTransportOptionsBuilder<()> { - PlainTransportOptionsBuilder(()) + pub fn builder() -> TupleNotificationBuilder<()> { + TupleNotificationBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_base: impl ::planus::WriteAs<::planus::Offset>, - field_listen_info: impl ::planus::WriteAs< - ::planus::Offset, - >, - field_rtcp_listen_info: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, - field_rtcp_mux: impl ::planus::WriteAsDefault, - field_comedia: impl ::planus::WriteAsDefault, - field_enable_srtp: impl ::planus::WriteAsDefault, - field_srtp_crypto_suite: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, - >, + field_tuple: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_base = field_base.prepare(builder); - let prepared_listen_info = field_listen_info.prepare(builder); - let prepared_rtcp_listen_info = field_rtcp_listen_info.prepare(builder); - let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); - let prepared_comedia = field_comedia.prepare(builder, &false); - let prepared_enable_srtp = field_enable_srtp.prepare(builder, &false); - let prepared_srtp_crypto_suite = field_srtp_crypto_suite.prepare(builder); + let prepared_tuple = field_tuple.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<18> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); - if prepared_rtcp_listen_info.is_some() { - table_writer - .write_entry::<::planus::Offset>(2); - } - if prepared_srtp_crypto_suite.is_some() { - table_writer.write_entry::<::planus::Offset>(6); - } - if prepared_rtcp_mux.is_some() { - table_writer.write_entry::(3); - } - if prepared_comedia.is_some() { - table_writer.write_entry::(4); - } - if prepared_enable_srtp.is_some() { - table_writer.write_entry::(5); - } + table_writer.write_entry::<::planus::Offset>(0); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_listen_info); - if let ::core::option::Option::Some(prepared_rtcp_listen_info) = - prepared_rtcp_listen_info - { - object_writer.write::<_, _, 4>(&prepared_rtcp_listen_info); - } - if let ::core::option::Option::Some(prepared_srtp_crypto_suite) = - prepared_srtp_crypto_suite - { - object_writer.write::<_, _, 4>(&prepared_srtp_crypto_suite); - } - if let ::core::option::Option::Some(prepared_rtcp_mux) = - prepared_rtcp_mux - { - object_writer.write::<_, _, 1>(&prepared_rtcp_mux); - } - if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia - { - object_writer.write::<_, _, 1>(&prepared_comedia); - } - if let ::core::option::Option::Some(prepared_enable_srtp) = - prepared_enable_srtp - { - object_writer.write::<_, _, 1>(&prepared_enable_srtp); - } + object_writer.write::<_, _, 4>(&prepared_tuple); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for PlainTransportOptions { + impl ::planus::WriteAs<::planus::Offset> for TupleNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for PlainTransportOptions { + impl ::planus::WriteAsOptional<::planus::Offset> for TupleNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for PlainTransportOptions { + impl ::planus::WriteAsOffset for TupleNotification { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - PlainTransportOptions::create( - builder, - &self.base, - &self.listen_info, - &self.rtcp_listen_info, - self.rtcp_mux, - self.comedia, - self.enable_srtp, - &self.srtp_crypto_suite, - ) + ) -> ::planus::Offset { + TupleNotification::create(builder, &self.tuple) } } - /// Builder for serializing an instance of the [PlainTransportOptions] type. + /// Builder for serializing an instance of the [TupleNotification] type. /// - /// Can be created using the [PlainTransportOptions::builder] method. + /// Can be created using the [TupleNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct PlainTransportOptionsBuilder(State); - - impl PlainTransportOptionsBuilder<()> { - /// Setter for the [`base` field](PlainTransportOptions#structfield.base). - #[inline] - #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> PlainTransportOptionsBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - PlainTransportOptionsBuilder((value,)) - } - } - - impl PlainTransportOptionsBuilder<(T0,)> { - /// Setter for the [`listen_info` field](PlainTransportOptions#structfield.listen_info). - #[inline] - #[allow(clippy::type_complexity)] - pub fn listen_info(self, value: T1) -> PlainTransportOptionsBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset>, - { - let (v0,) = self.0; - PlainTransportOptionsBuilder((v0, value)) - } - } - - impl PlainTransportOptionsBuilder<(T0, T1)> { - /// Setter for the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_listen_info( - self, - value: T2, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsOptional<::planus::Offset>, - { - let (v0, v1) = self.0; - PlainTransportOptionsBuilder((v0, v1, value)) - } - - /// Sets the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_listen_info_as_null( - self, - ) -> PlainTransportOptionsBuilder<(T0, T1, ())> { - self.rtcp_listen_info(()) - } - } - - impl PlainTransportOptionsBuilder<(T0, T1, T2)> { - /// Setter for the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux( - self, - value: T3, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAsDefault, - { - let (v0, v1, v2) = self.0; - PlainTransportOptionsBuilder((v0, v1, v2, value)) - } - - /// Sets the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux_as_default( - self, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, ::planus::DefaultValue)> - { - self.rtcp_mux(::planus::DefaultValue) - } - } - - impl PlainTransportOptionsBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`comedia` field](PlainTransportOptions#structfield.comedia). - #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia( - self, - value: T4, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4)> - where - T4: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3) = self.0; - PlainTransportOptionsBuilder((v0, v1, v2, v3, value)) - } - - /// Sets the [`comedia` field](PlainTransportOptions#structfield.comedia) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia_as_default( - self, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> - { - self.comedia(::planus::DefaultValue) - } - } - - impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp). - #[inline] - #[allow(clippy::type_complexity)] - pub fn enable_srtp( - self, - value: T5, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5)> - where - T5: ::planus::WriteAsDefault, - { - let (v0, v1, v2, v3, v4) = self.0; - PlainTransportOptionsBuilder((v0, v1, v2, v3, v4, value)) - } - - /// Sets the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn enable_srtp_as_default( - self, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)> - { - self.enable_srtp(::planus::DefaultValue) - } - } + pub struct TupleNotificationBuilder(State); - impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Setter for the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite). + impl TupleNotificationBuilder<()> { + /// Setter for the [`tuple` field](TupleNotification#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_crypto_suite( - self, - value: T6, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> + pub fn tuple(self, value: T0) -> TupleNotificationBuilder<(T0,)> where - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T0: ::planus::WriteAs<::planus::Offset>, { - let (v0, v1, v2, v3, v4, v5) = self.0; - PlainTransportOptionsBuilder((v0, v1, v2, v3, v4, v5, value)) - } - - /// Sets the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn srtp_crypto_suite_as_null( - self, - ) -> PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, ())> { - self.srtp_crypto_suite(()) + TupleNotificationBuilder((value,)) } } - impl PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PlainTransportOptions]. + impl TupleNotificationBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TupleNotification]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAs<::planus::Offset> - for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOptional<::planus::Offset> - for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> - { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - T3: ::planus::WriteAsDefault, - T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsDefault, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOffset - for PlainTransportOptionsBuilder<(T0, T1, T2, T3, T4, T5, T6)> - { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5, v6) = &self.0; - PlainTransportOptions::create(builder, v0, v1, v2, v3, v4, v5, v6) - } - } - - /// Reference to a deserialized [PlainTransportOptions]. - #[derive(Copy, Clone)] - pub struct PlainTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> PlainTransportOptionsRef<'a> { - /// Getter for the [`base` field](PlainTransportOptions#structfield.base). - #[inline] - pub fn base(&self) -> ::planus::Result> { - self.0.access_required(0, "PlainTransportOptions", "base") - } - - /// Getter for the [`listen_info` field](PlainTransportOptions#structfield.listen_info). - #[inline] - pub fn listen_info(&self) -> ::planus::Result> { - self.0 - .access_required(1, "PlainTransportOptions", "listen_info") - } - - /// Getter for the [`rtcp_listen_info` field](PlainTransportOptions#structfield.rtcp_listen_info). - #[inline] - pub fn rtcp_listen_info( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0 - .access(2, "PlainTransportOptions", "rtcp_listen_info") - } + impl>> + ::planus::WriteAs<::planus::Offset> + for TupleNotificationBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// Getter for the [`rtcp_mux` field](PlainTransportOptions#structfield.rtcp_mux). #[inline] - pub fn rtcp_mux(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(3, "PlainTransportOptions", "rtcp_mux")? - .unwrap_or(false), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + ::planus::WriteAsOffset::prepare(self, builder) } + } + + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for TupleNotificationBuilder<(T0,)> + { + type Prepared = ::planus::Offset; - /// Getter for the [`comedia` field](PlainTransportOptions#structfield.comedia). #[inline] - pub fn comedia(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(4, "PlainTransportOptions", "comedia")? - .unwrap_or(false), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::Offset> { + ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } + } - /// Getter for the [`enable_srtp` field](PlainTransportOptions#structfield.enable_srtp). + impl>> + ::planus::WriteAsOffset for TupleNotificationBuilder<(T0,)> + { #[inline] - pub fn enable_srtp(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(5, "PlainTransportOptions", "enable_srtp")? - .unwrap_or(false), - ) + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + let (v0,) = &self.0; + TupleNotification::create(builder, v0) } + } - /// Getter for the [`srtp_crypto_suite` field](PlainTransportOptions#structfield.srtp_crypto_suite). + /// Reference to a deserialized [TupleNotification]. + #[derive(Copy, Clone)] + pub struct TupleNotificationRef<'a>(::planus::table_reader::Table<'a>); + + impl<'a> TupleNotificationRef<'a> { + /// Getter for the [`tuple` field](TupleNotification#structfield.tuple). #[inline] - pub fn srtp_crypto_suite( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0 - .access(6, "PlainTransportOptions", "srtp_crypto_suite") + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(0, "TupleNotification", "tuple") } } - impl<'a> ::core::fmt::Debug for PlainTransportOptionsRef<'a> { + impl<'a> ::core::fmt::Debug for TupleNotificationRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("PlainTransportOptionsRef"); - f.field("base", &self.base()); - f.field("listen_info", &self.listen_info()); - if let ::core::option::Option::Some(field_rtcp_listen_info) = - self.rtcp_listen_info().transpose() - { - f.field("rtcp_listen_info", &field_rtcp_listen_info); - } - f.field("rtcp_mux", &self.rtcp_mux()); - f.field("comedia", &self.comedia()); - f.field("enable_srtp", &self.enable_srtp()); - if let ::core::option::Option::Some(field_srtp_crypto_suite) = - self.srtp_crypto_suite().transpose() - { - f.field("srtp_crypto_suite", &field_srtp_crypto_suite); - } + let mut f = f.debug_struct("TupleNotificationRef"); + f.field("tuple", &self.tuple()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for PlainTransportOptions { + impl<'a> ::core::convert::TryFrom> for TupleNotification { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: PlainTransportOptionsRef<'a>) -> ::planus::Result { + fn try_from(value: TupleNotificationRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( - value.base()?, - )?), - listen_info: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.listen_info()?)?, + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, ), - rtcp_listen_info: if let ::core::option::Option::Some(rtcp_listen_info) = - value.rtcp_listen_info()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(rtcp_listen_info)?, - )) - } else { - ::core::option::Option::None - }, - rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, - comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, - enable_srtp: ::core::convert::TryInto::try_into(value.enable_srtp()?)?, - srtp_crypto_suite: if let ::core::option::Option::Some(srtp_crypto_suite) = - value.srtp_crypto_suite()? - { - ::core::option::Option::Some(::core::convert::TryInto::try_into( - srtp_crypto_suite, - )?) - } else { - ::core::option::Option::None - }, }) } } - impl<'a> ::planus::TableRead<'a> for PlainTransportOptionsRef<'a> { + impl<'a> ::planus::TableRead<'a> for TupleNotificationRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -71517,7 +73885,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for PlainTransportOptionsRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for TupleNotificationRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -71527,7 +73895,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[PlainTransportOptionsRef]", + "[TupleNotificationRef]", "get", buffer.offset_from_start, ) @@ -71535,8 +73903,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for PlainTransportOptions { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for TupleNotification { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -71545,7 +73913,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -71560,7 +73928,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for PlainTransportOptionsRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for TupleNotificationRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -71570,19 +73938,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[PlainTransportOptionsRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[TupleNotificationRef]", "read_as_root", 0) }) } } - /// The table `ConnectRequest` in the namespace `FBS.PlainTransport` + /// The table `RtcpTupleNotification` in the namespace `FBS.PlainTransport` /// /// Generated from these locations: - /// * Table `ConnectRequest` in the file `../worker/fbs/plainTransport.fbs:16` + /// * Table `RtcpTupleNotification` in the file `../worker/fbs/plainTransport.fbs:53` #[derive( Clone, Debug, @@ -71594,392 +73958,185 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct ConnectRequest { - /// The field `ip` in the table `ConnectRequest` - pub ip: ::core::option::Option<::planus::alloc::string::String>, - /// The field `port` in the table `ConnectRequest` - pub port: ::core::option::Option, - /// The field `rtcp_port` in the table `ConnectRequest` - pub rtcp_port: ::core::option::Option, - /// The field `srtp_parameters` in the table `ConnectRequest` - pub srtp_parameters: ::core::option::Option< - ::planus::alloc::boxed::Box, - >, - } - - #[allow(clippy::derivable_impls)] - impl ::core::default::Default for ConnectRequest { - fn default() -> Self { - Self { - ip: ::core::default::Default::default(), - port: ::core::default::Default::default(), - rtcp_port: ::core::default::Default::default(), - srtp_parameters: ::core::default::Default::default(), - } - } + pub struct RtcpTupleNotification { + /// The field `tuple` in the table `RtcpTupleNotification` + pub tuple: ::planus::alloc::boxed::Box, } - impl ConnectRequest { - /// Creates a [ConnectRequestBuilder] for serializing an instance of this table. + impl RtcpTupleNotification { + /// Creates a [RtcpTupleNotificationBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ConnectRequestBuilder<()> { - ConnectRequestBuilder(()) + pub fn builder() -> RtcpTupleNotificationBuilder<()> { + RtcpTupleNotificationBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_ip: impl ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - field_port: impl ::planus::WriteAsOptional, - field_rtcp_port: impl ::planus::WriteAsOptional, - field_srtp_parameters: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, + field_tuple: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_ip = field_ip.prepare(builder); - let prepared_port = field_port.prepare(builder); - let prepared_rtcp_port = field_rtcp_port.prepare(builder); - let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); + let prepared_tuple = field_tuple.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<12> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - if prepared_ip.is_some() { - table_writer.write_entry::<::planus::Offset>(0); - } - if prepared_srtp_parameters.is_some() { - table_writer - .write_entry::<::planus::Offset>(3); - } - if prepared_port.is_some() { - table_writer.write_entry::(1); - } - if prepared_rtcp_port.is_some() { - table_writer.write_entry::(2); - } + table_writer.write_entry::<::planus::Offset>(0); unsafe { table_writer.finish(builder, |object_writer| { - if let ::core::option::Option::Some(prepared_ip) = prepared_ip { - object_writer.write::<_, _, 4>(&prepared_ip); - } - if let ::core::option::Option::Some(prepared_srtp_parameters) = - prepared_srtp_parameters - { - object_writer.write::<_, _, 4>(&prepared_srtp_parameters); - } - if let ::core::option::Option::Some(prepared_port) = prepared_port { - object_writer.write::<_, _, 2>(&prepared_port); - } - if let ::core::option::Option::Some(prepared_rtcp_port) = - prepared_rtcp_port - { - object_writer.write::<_, _, 2>(&prepared_rtcp_port); - } + object_writer.write::<_, _, 4>(&prepared_tuple); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for ConnectRequest { + impl ::planus::WriteAs<::planus::Offset> for RtcpTupleNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for ConnectRequest { + impl ::planus::WriteAsOptional<::planus::Offset> for RtcpTupleNotification { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for ConnectRequest { + impl ::planus::WriteAsOffset for RtcpTupleNotification { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ConnectRequest::create( - builder, - &self.ip, - self.port, - self.rtcp_port, - &self.srtp_parameters, - ) + ) -> ::planus::Offset { + RtcpTupleNotification::create(builder, &self.tuple) } } - /// Builder for serializing an instance of the [ConnectRequest] type. + /// Builder for serializing an instance of the [RtcpTupleNotification] type. /// - /// Can be created using the [ConnectRequest::builder] method. + /// Can be created using the [RtcpTupleNotification::builder] method. #[derive(Debug)] #[must_use] - pub struct ConnectRequestBuilder(State); - - impl ConnectRequestBuilder<()> { - /// Setter for the [`ip` field](ConnectRequest#structfield.ip). - #[inline] - #[allow(clippy::type_complexity)] - pub fn ip(self, value: T0) -> ConnectRequestBuilder<(T0,)> - where - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - { - ConnectRequestBuilder((value,)) - } - - /// Sets the [`ip` field](ConnectRequest#structfield.ip) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn ip_as_null(self) -> ConnectRequestBuilder<((),)> { - self.ip(()) - } - } - - impl ConnectRequestBuilder<(T0,)> { - /// Setter for the [`port` field](ConnectRequest#structfield.port). - #[inline] - #[allow(clippy::type_complexity)] - pub fn port(self, value: T1) -> ConnectRequestBuilder<(T0, T1)> - where - T1: ::planus::WriteAsOptional, - { - let (v0,) = self.0; - ConnectRequestBuilder((v0, value)) - } - - /// Sets the [`port` field](ConnectRequest#structfield.port) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn port_as_null(self) -> ConnectRequestBuilder<(T0, ())> { - self.port(()) - } - } - - impl ConnectRequestBuilder<(T0, T1)> { - /// Setter for the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_port(self, value: T2) -> ConnectRequestBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsOptional, - { - let (v0, v1) = self.0; - ConnectRequestBuilder((v0, v1, value)) - } - - /// Sets the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_port_as_null(self) -> ConnectRequestBuilder<(T0, T1, ())> { - self.rtcp_port(()) - } - } + pub struct RtcpTupleNotificationBuilder(State); - impl ConnectRequestBuilder<(T0, T1, T2)> { - /// Setter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + impl RtcpTupleNotificationBuilder<()> { + /// Setter for the [`tuple` field](RtcpTupleNotification#structfield.tuple). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters( - self, - value: T3, - ) -> ConnectRequestBuilder<(T0, T1, T2, T3)> + pub fn tuple(self, value: T0) -> RtcpTupleNotificationBuilder<(T0,)> where - T3: ::planus::WriteAsOptional< - ::planus::Offset, - >, + T0: ::planus::WriteAs<::planus::Offset>, { - let (v0, v1, v2) = self.0; - ConnectRequestBuilder((v0, v1, v2, value)) - } - - /// Sets the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn srtp_parameters_as_null(self) -> ConnectRequestBuilder<(T0, T1, T2, ())> { - self.srtp_parameters(()) + RtcpTupleNotificationBuilder((value,)) } } - impl ConnectRequestBuilder<(T0, T1, T2, T3)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectRequest]. + impl RtcpTupleNotificationBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [RtcpTupleNotification]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional, - T3: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for ConnectRequestBuilder<(T0, T1, T2, T3)> + impl>> + ::planus::WriteAs<::planus::Offset> + for RtcpTupleNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional, - T3: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for ConnectRequestBuilder<(T0, T1, T2, T3)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for RtcpTupleNotificationBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T1: ::planus::WriteAsOptional, - T2: ::planus::WriteAsOptional, - T3: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset - for ConnectRequestBuilder<(T0, T1, T2, T3)> + impl>> + ::planus::WriteAsOffset + for RtcpTupleNotificationBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3) = &self.0; - ConnectRequest::create(builder, v0, v1, v2, v3) + ) -> ::planus::Offset { + let (v0,) = &self.0; + RtcpTupleNotification::create(builder, v0) } } - /// Reference to a deserialized [ConnectRequest]. + /// Reference to a deserialized [RtcpTupleNotification]. #[derive(Copy, Clone)] - pub struct ConnectRequestRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> ConnectRequestRef<'a> { - /// Getter for the [`ip` field](ConnectRequest#structfield.ip). - #[inline] - pub fn ip( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(0, "ConnectRequest", "ip") - } - - /// Getter for the [`port` field](ConnectRequest#structfield.port). - #[inline] - pub fn port(&self) -> ::planus::Result<::core::option::Option> { - self.0.access(1, "ConnectRequest", "port") - } - - /// Getter for the [`rtcp_port` field](ConnectRequest#structfield.rtcp_port). - #[inline] - pub fn rtcp_port(&self) -> ::planus::Result<::core::option::Option> { - self.0.access(2, "ConnectRequest", "rtcp_port") - } + pub struct RtcpTupleNotificationRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`srtp_parameters` field](ConnectRequest#structfield.srtp_parameters). + impl<'a> RtcpTupleNotificationRef<'a> { + /// Getter for the [`tuple` field](RtcpTupleNotification#structfield.tuple). #[inline] - pub fn srtp_parameters( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(3, "ConnectRequest", "srtp_parameters") + pub fn tuple(&self) -> ::planus::Result> { + self.0.access_required(0, "RtcpTupleNotification", "tuple") } } - impl<'a> ::core::fmt::Debug for ConnectRequestRef<'a> { + impl<'a> ::core::fmt::Debug for RtcpTupleNotificationRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ConnectRequestRef"); - if let ::core::option::Option::Some(field_ip) = self.ip().transpose() { - f.field("ip", &field_ip); - } - if let ::core::option::Option::Some(field_port) = self.port().transpose() { - f.field("port", &field_port); - } - if let ::core::option::Option::Some(field_rtcp_port) = - self.rtcp_port().transpose() - { - f.field("rtcp_port", &field_rtcp_port); - } - if let ::core::option::Option::Some(field_srtp_parameters) = - self.srtp_parameters().transpose() - { - f.field("srtp_parameters", &field_srtp_parameters); - } + let mut f = f.debug_struct("RtcpTupleNotificationRef"); + f.field("tuple", &self.tuple()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ConnectRequest { + impl<'a> ::core::convert::TryFrom> for RtcpTupleNotification { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ConnectRequestRef<'a>) -> ::planus::Result { + fn try_from(value: RtcpTupleNotificationRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - ip: if let ::core::option::Option::Some(ip) = value.ip()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(ip)?) - } else { - ::core::option::Option::None - }, - port: if let ::core::option::Option::Some(port) = value.port()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(port)?) - } else { - ::core::option::Option::None - }, - rtcp_port: if let ::core::option::Option::Some(rtcp_port) = - value.rtcp_port()? - { - ::core::option::Option::Some(::core::convert::TryInto::try_into( - rtcp_port, - )?) - } else { - ::core::option::Option::None - }, - srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = - value.srtp_parameters()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(srtp_parameters)?, - )) - } else { - ::core::option::Option::None - }, + tuple: ::planus::alloc::boxed::Box::new( + ::core::convert::TryInto::try_into(value.tuple()?)?, + ), }) } } - impl<'a> ::planus::TableRead<'a> for ConnectRequestRef<'a> { + impl<'a> ::planus::TableRead<'a> for RtcpTupleNotificationRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -71991,7 +74148,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ConnectRequestRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for RtcpTupleNotificationRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -72001,7 +74158,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ConnectRequestRef]", + "[RtcpTupleNotificationRef]", "get", buffer.offset_from_start, ) @@ -72009,8 +74166,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ConnectRequest { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for RtcpTupleNotification { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -72019,7 +74176,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -72034,7 +74191,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ConnectRequestRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for RtcpTupleNotificationRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -72044,337 +74201,227 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[ConnectRequestRef]", "read_as_root", 0) + error_kind.with_error_location( + "[RtcpTupleNotificationRef]", + "read_as_root", + 0, + ) }) } } - - /// The table `ConnectResponse` in the namespace `FBS.PlainTransport` + } + /// The namespace `FBS.WebRtcTransport` + /// + /// Generated from these locations: + /// * File `../worker/fbs/webRtcTransport.fbs` + pub mod web_rtc_transport { + /// The table `ListenIndividual` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `ConnectResponse` in the file `../worker/fbs/plainTransport.fbs:23` + /// * Table `ListenIndividual` in the file `../worker/fbs/webRtcTransport.fbs:6` #[derive( Clone, Debug, - PartialEq, - PartialOrd, - Eq, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - pub struct ConnectResponse { - /// The field `tuple` in the table `ConnectResponse` - pub tuple: ::planus::alloc::boxed::Box, - /// The field `rtcp_tuple` in the table `ConnectResponse` - pub rtcp_tuple: - ::core::option::Option<::planus::alloc::boxed::Box>, - /// The field `srtp_parameters` in the table `ConnectResponse` - pub srtp_parameters: ::core::option::Option< - ::planus::alloc::boxed::Box, - >, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + pub struct ListenIndividual { + /// The field `listen_infos` in the table `ListenIndividual` + pub listen_infos: ::planus::alloc::vec::Vec, } - impl ConnectResponse { - /// Creates a [ConnectResponseBuilder] for serializing an instance of this table. + impl ListenIndividual { + /// Creates a [ListenIndividualBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ConnectResponseBuilder<()> { - ConnectResponseBuilder(()) + pub fn builder() -> ListenIndividualBuilder<()> { + ListenIndividualBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_tuple: impl ::planus::WriteAs<::planus::Offset>, - field_rtcp_tuple: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, - field_srtp_parameters: impl ::planus::WriteAsOptional< - ::planus::Offset, + field_listen_infos: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, >, ) -> ::planus::Offset { - let prepared_tuple = field_tuple.prepare(builder); - let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); - let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); + let prepared_listen_infos = field_listen_infos.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - if prepared_rtcp_tuple.is_some() { - table_writer.write_entry::<::planus::Offset>(1); - } - if prepared_srtp_parameters.is_some() { - table_writer - .write_entry::<::planus::Offset>(2); - } + table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_tuple); - if let ::core::option::Option::Some(prepared_rtcp_tuple) = - prepared_rtcp_tuple - { - object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); - } - if let ::core::option::Option::Some(prepared_srtp_parameters) = - prepared_srtp_parameters - { - object_writer.write::<_, _, 4>(&prepared_srtp_parameters); - } + object_writer.write::<_, _, 4>(&prepared_listen_infos); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for ConnectResponse { + impl ::planus::WriteAs<::planus::Offset> for ListenIndividual { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for ConnectResponse { + impl ::planus::WriteAsOptional<::planus::Offset> for ListenIndividual { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for ConnectResponse { + impl ::planus::WriteAsOffset for ListenIndividual { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ConnectResponse::create( - builder, - &self.tuple, - &self.rtcp_tuple, - &self.srtp_parameters, - ) + ) -> ::planus::Offset { + ListenIndividual::create(builder, &self.listen_infos) } } - /// Builder for serializing an instance of the [ConnectResponse] type. + /// Builder for serializing an instance of the [ListenIndividual] type. /// - /// Can be created using the [ConnectResponse::builder] method. + /// Can be created using the [ListenIndividual::builder] method. #[derive(Debug)] #[must_use] - pub struct ConnectResponseBuilder(State); - - impl ConnectResponseBuilder<()> { - /// Setter for the [`tuple` field](ConnectResponse#structfield.tuple). - #[inline] - #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T0) -> ConnectResponseBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - ConnectResponseBuilder((value,)) - } - } - - impl ConnectResponseBuilder<(T0,)> { - /// Setter for the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple(self, value: T1) -> ConnectResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAsOptional<::planus::Offset>, - { - let (v0,) = self.0; - ConnectResponseBuilder((v0, value)) - } - - /// Sets the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple_as_null(self) -> ConnectResponseBuilder<(T0, ())> { - self.rtcp_tuple(()) - } - } + pub struct ListenIndividualBuilder(State); - impl ConnectResponseBuilder<(T0, T1)> { - /// Setter for the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters). + impl ListenIndividualBuilder<()> { + /// Setter for the [`listen_infos` field](ListenIndividual#structfield.listen_infos). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters(self, value: T2) -> ConnectResponseBuilder<(T0, T1, T2)> + pub fn listen_infos(self, value: T0) -> ListenIndividualBuilder<(T0,)> where - T2: ::planus::WriteAsOptional< - ::planus::Offset, + T0: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, >, { - let (v0, v1) = self.0; - ConnectResponseBuilder((v0, v1, value)) - } - - /// Sets the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn srtp_parameters_as_null(self) -> ConnectResponseBuilder<(T0, T1, ())> { - self.srtp_parameters(()) + ListenIndividualBuilder((value,)) } } - impl ConnectResponseBuilder<(T0, T1, T2)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ConnectResponse]. + impl ListenIndividualBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ListenIndividual]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for ConnectResponseBuilder<(T0, T1, T2)> + T0: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAs<::planus::Offset> + for ListenIndividualBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for ConnectResponseBuilder<(T0, T1, T2)> + T0: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOptional<::planus::Offset> + for ListenIndividualBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsOptional<::planus::Offset>, - T2: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset - for ConnectResponseBuilder<(T0, T1, T2)> + T0: ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + > ::planus::WriteAsOffset for ListenIndividualBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - ConnectResponse::create(builder, v0, v1, v2) + ) -> ::planus::Offset { + let (v0,) = &self.0; + ListenIndividual::create(builder, v0) } } - /// Reference to a deserialized [ConnectResponse]. + /// Reference to a deserialized [ListenIndividual]. #[derive(Copy, Clone)] - pub struct ConnectResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> ConnectResponseRef<'a> { - /// Getter for the [`tuple` field](ConnectResponse#structfield.tuple). - #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(0, "ConnectResponse", "tuple") - } - - /// Getter for the [`rtcp_tuple` field](ConnectResponse#structfield.rtcp_tuple). - #[inline] - pub fn rtcp_tuple( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(1, "ConnectResponse", "rtcp_tuple") - } + pub struct ListenIndividualRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`srtp_parameters` field](ConnectResponse#structfield.srtp_parameters). + impl<'a> ListenIndividualRef<'a> { + /// Getter for the [`listen_infos` field](ListenIndividual#structfield.listen_infos). #[inline] - pub fn srtp_parameters( + pub fn listen_infos( &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(2, "ConnectResponse", "srtp_parameters") + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0 + .access_required(0, "ListenIndividual", "listen_infos") } } - impl<'a> ::core::fmt::Debug for ConnectResponseRef<'a> { + impl<'a> ::core::fmt::Debug for ListenIndividualRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ConnectResponseRef"); - f.field("tuple", &self.tuple()); - if let ::core::option::Option::Some(field_rtcp_tuple) = - self.rtcp_tuple().transpose() - { - f.field("rtcp_tuple", &field_rtcp_tuple); - } - if let ::core::option::Option::Some(field_srtp_parameters) = - self.srtp_parameters().transpose() - { - f.field("srtp_parameters", &field_srtp_parameters); - } + let mut f = f.debug_struct("ListenIndividualRef"); + f.field("listen_infos", &self.listen_infos()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ConnectResponse { + impl<'a> ::core::convert::TryFrom> for ListenIndividual { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ConnectResponseRef<'a>) -> ::planus::Result { + fn try_from(value: ListenIndividualRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - tuple: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.tuple()?)?, - ), - rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = - value.rtcp_tuple()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(rtcp_tuple)?, - )) - } else { - ::core::option::Option::None - }, - srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = - value.srtp_parameters()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(srtp_parameters)?, - )) - } else { - ::core::option::Option::None - }, + listen_infos: value.listen_infos()?.to_vec_result()?, }) } } - impl<'a> ::planus::TableRead<'a> for ConnectResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for ListenIndividualRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -72386,7 +74433,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ConnectResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ListenIndividualRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -72396,7 +74443,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ConnectResponseRef]", + "[ListenIndividualRef]", "get", buffer.offset_from_start, ) @@ -72404,8 +74451,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ConnectResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ListenIndividual { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -72414,7 +74461,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -72429,7 +74476,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ConnectResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ListenIndividualRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -72439,15 +74486,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[ConnectResponseRef]", "read_as_root", 0) + error_kind.with_error_location("[ListenIndividualRef]", "read_as_root", 0) }) } } - /// The table `DumpResponse` in the namespace `FBS.PlainTransport` + /// The table `ListenServer` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/plainTransport.fbs:29` + /// * Table `ListenServer` in the file `../worker/fbs/webRtcTransport.fbs:10` #[derive( Clone, Debug, @@ -72459,454 +74506,182 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct DumpResponse { - /// The field `base` in the table `DumpResponse` - pub base: ::planus::alloc::boxed::Box, - /// The field `rtcp_mux` in the table `DumpResponse` - pub rtcp_mux: bool, - /// The field `comedia` in the table `DumpResponse` - pub comedia: bool, - /// The field `tuple` in the table `DumpResponse` - pub tuple: ::planus::alloc::boxed::Box, - /// The field `rtcp_tuple` in the table `DumpResponse` - pub rtcp_tuple: - ::core::option::Option<::planus::alloc::boxed::Box>, - /// The field `srtp_parameters` in the table `DumpResponse` - pub srtp_parameters: ::core::option::Option< - ::planus::alloc::boxed::Box, - >, + pub struct ListenServer { + /// The field `web_rtc_server_id` in the table `ListenServer` + pub web_rtc_server_id: ::planus::alloc::string::String, } - impl DumpResponse { - /// Creates a [DumpResponseBuilder] for serializing an instance of this table. + impl ListenServer { + /// Creates a [ListenServerBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> DumpResponseBuilder<()> { - DumpResponseBuilder(()) + pub fn builder() -> ListenServerBuilder<()> { + ListenServerBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_base: impl ::planus::WriteAs<::planus::Offset>, - field_rtcp_mux: impl ::planus::WriteAsDefault, - field_comedia: impl ::planus::WriteAsDefault, - field_tuple: impl ::planus::WriteAs<::planus::Offset>, - field_rtcp_tuple: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, - field_srtp_parameters: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, + field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_base = field_base.prepare(builder); - let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); - let prepared_comedia = field_comedia.prepare(builder, &false); - let prepared_tuple = field_tuple.prepare(builder); - let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); - let prepared_srtp_parameters = field_srtp_parameters.prepare(builder); + let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<16> = + let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(3); - if prepared_rtcp_tuple.is_some() { - table_writer.write_entry::<::planus::Offset>(4); - } - if prepared_srtp_parameters.is_some() { - table_writer - .write_entry::<::planus::Offset>(5); - } - if prepared_rtcp_mux.is_some() { - table_writer.write_entry::(1); - } - if prepared_comedia.is_some() { - table_writer.write_entry::(2); - } + table_writer.write_entry::<::planus::Offset>(0); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_tuple); - if let ::core::option::Option::Some(prepared_rtcp_tuple) = - prepared_rtcp_tuple - { - object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); - } - if let ::core::option::Option::Some(prepared_srtp_parameters) = - prepared_srtp_parameters - { - object_writer.write::<_, _, 4>(&prepared_srtp_parameters); - } - if let ::core::option::Option::Some(prepared_rtcp_mux) = - prepared_rtcp_mux - { - object_writer.write::<_, _, 1>(&prepared_rtcp_mux); - } - if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia - { - object_writer.write::<_, _, 1>(&prepared_comedia); - } + object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for DumpResponse { + impl ::planus::WriteAs<::planus::Offset> for ListenServer { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for DumpResponse { + impl ::planus::WriteAsOptional<::planus::Offset> for ListenServer { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for DumpResponse { + impl ::planus::WriteAsOffset for ListenServer { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DumpResponse::create( - builder, - &self.base, - self.rtcp_mux, - self.comedia, - &self.tuple, - &self.rtcp_tuple, - &self.srtp_parameters, - ) + ) -> ::planus::Offset { + ListenServer::create(builder, &self.web_rtc_server_id) } } - /// Builder for serializing an instance of the [DumpResponse] type. + /// Builder for serializing an instance of the [ListenServer] type. /// - /// Can be created using the [DumpResponse::builder] method. + /// Can be created using the [ListenServer::builder] method. #[derive(Debug)] #[must_use] - pub struct DumpResponseBuilder(State); - - impl DumpResponseBuilder<()> { - /// Setter for the [`base` field](DumpResponse#structfield.base). - #[inline] - #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> DumpResponseBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - DumpResponseBuilder((value,)) - } - } - - impl DumpResponseBuilder<(T0,)> { - /// Setter for the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux(self, value: T1) -> DumpResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault, - { - let (v0,) = self.0; - DumpResponseBuilder((v0, value)) - } - - /// Sets the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux_as_default( - self, - ) -> DumpResponseBuilder<(T0, ::planus::DefaultValue)> { - self.rtcp_mux(::planus::DefaultValue) - } - } - - impl DumpResponseBuilder<(T0, T1)> { - /// Setter for the [`comedia` field](DumpResponse#structfield.comedia). - #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia(self, value: T2) -> DumpResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsDefault, - { - let (v0, v1) = self.0; - DumpResponseBuilder((v0, v1, value)) - } - - /// Sets the [`comedia` field](DumpResponse#structfield.comedia) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia_as_default( - self, - ) -> DumpResponseBuilder<(T0, T1, ::planus::DefaultValue)> { - self.comedia(::planus::DefaultValue) - } - } - - impl DumpResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`tuple` field](DumpResponse#structfield.tuple). - #[inline] - #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T3) -> DumpResponseBuilder<(T0, T1, T2, T3)> - where - T3: ::planus::WriteAs<::planus::Offset>, - { - let (v0, v1, v2) = self.0; - DumpResponseBuilder((v0, v1, v2, value)) - } - } - - impl DumpResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple(self, value: T4) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> - where - T4: ::planus::WriteAsOptional<::planus::Offset>, - { - let (v0, v1, v2, v3) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, value)) - } - - /// Sets the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple_as_null(self) -> DumpResponseBuilder<(T0, T1, T2, T3, ())> { - self.rtcp_tuple(()) - } - } + pub struct ListenServerBuilder(State); - impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Setter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + impl ListenServerBuilder<()> { + /// Setter for the [`web_rtc_server_id` field](ListenServer#structfield.web_rtc_server_id). #[inline] #[allow(clippy::type_complexity)] - pub fn srtp_parameters( - self, - value: T5, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + pub fn web_rtc_server_id(self, value: T0) -> ListenServerBuilder<(T0,)> where - T5: ::planus::WriteAsOptional< - ::planus::Offset, - >, + T0: ::planus::WriteAs<::planus::Offset>, { - let (v0, v1, v2, v3, v4) = self.0; - DumpResponseBuilder((v0, v1, v2, v3, v4, value)) - } - - /// Sets the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn srtp_parameters_as_null( - self, - ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, ())> { - self.srtp_parameters(()) + ListenServerBuilder((value,)) } } - impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DumpResponse]. + impl ListenServerBuilder<(T0,)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ListenServer]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) - } - } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - T5: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + Self: ::planus::WriteAsOffset, + { + ::planus::WriteAsOffset::prepare(&self, builder) + } + } + + impl>> + ::planus::WriteAs<::planus::Offset> for ListenServerBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - T5: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + impl>> + ::planus::WriteAsOptional<::planus::Offset> + for ListenServerBuilder<(T0,)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - T5: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset - for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5)> + impl>> ::planus::WriteAsOffset + for ListenServerBuilder<(T0,)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4, v5) = &self.0; - DumpResponse::create(builder, v0, v1, v2, v3, v4, v5) + ) -> ::planus::Offset { + let (v0,) = &self.0; + ListenServer::create(builder, v0) } } - /// Reference to a deserialized [DumpResponse]. + /// Reference to a deserialized [ListenServer]. #[derive(Copy, Clone)] - pub struct DumpResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> DumpResponseRef<'a> { - /// Getter for the [`base` field](DumpResponse#structfield.base). - #[inline] - pub fn base(&self) -> ::planus::Result> { - self.0.access_required(0, "DumpResponse", "base") - } - - /// Getter for the [`rtcp_mux` field](DumpResponse#structfield.rtcp_mux). - #[inline] - pub fn rtcp_mux(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "DumpResponse", "rtcp_mux")? - .unwrap_or(false), - ) - } - - /// Getter for the [`comedia` field](DumpResponse#structfield.comedia). - #[inline] - pub fn comedia(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "DumpResponse", "comedia")? - .unwrap_or(false), - ) - } - - /// Getter for the [`tuple` field](DumpResponse#structfield.tuple). - #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(3, "DumpResponse", "tuple") - } - - /// Getter for the [`rtcp_tuple` field](DumpResponse#structfield.rtcp_tuple). - #[inline] - pub fn rtcp_tuple( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(4, "DumpResponse", "rtcp_tuple") - } + pub struct ListenServerRef<'a>(::planus::table_reader::Table<'a>); - /// Getter for the [`srtp_parameters` field](DumpResponse#structfield.srtp_parameters). + impl<'a> ListenServerRef<'a> { + /// Getter for the [`web_rtc_server_id` field](ListenServer#structfield.web_rtc_server_id). #[inline] - pub fn srtp_parameters( - &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(5, "DumpResponse", "srtp_parameters") + pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "ListenServer", "web_rtc_server_id") } } - impl<'a> ::core::fmt::Debug for DumpResponseRef<'a> { + impl<'a> ::core::fmt::Debug for ListenServerRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DumpResponseRef"); - f.field("base", &self.base()); - f.field("rtcp_mux", &self.rtcp_mux()); - f.field("comedia", &self.comedia()); - f.field("tuple", &self.tuple()); - if let ::core::option::Option::Some(field_rtcp_tuple) = - self.rtcp_tuple().transpose() - { - f.field("rtcp_tuple", &field_rtcp_tuple); - } - if let ::core::option::Option::Some(field_srtp_parameters) = - self.srtp_parameters().transpose() - { - f.field("srtp_parameters", &field_srtp_parameters); - } + let mut f = f.debug_struct("ListenServerRef"); + f.field("web_rtc_server_id", &self.web_rtc_server_id()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for DumpResponse { + impl<'a> ::core::convert::TryFrom> for ListenServer { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: DumpResponseRef<'a>) -> ::planus::Result { + fn try_from(value: ListenServerRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( - value.base()?, - )?), - rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, - comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, - tuple: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.tuple()?)?, - ), - rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = - value.rtcp_tuple()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(rtcp_tuple)?, - )) - } else { - ::core::option::Option::None - }, - srtp_parameters: if let ::core::option::Option::Some(srtp_parameters) = - value.srtp_parameters()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(srtp_parameters)?, - )) - } else { - ::core::option::Option::None - }, + web_rtc_server_id: ::core::convert::TryInto::try_into( + value.web_rtc_server_id()?, + )?, }) } } - impl<'a> ::planus::TableRead<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::TableRead<'a> for ListenServerRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -72918,7 +74693,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for ListenServerRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -72928,7 +74703,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[DumpResponseRef]", + "[ListenServerRef]", "get", buffer.offset_from_start, ) @@ -72936,8 +74711,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for DumpResponse { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for ListenServer { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -72946,7 +74721,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -72961,7 +74736,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for DumpResponseRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for ListenServerRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -72971,471 +74746,229 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[DumpResponseRef]", "read_as_root", 0) + error_kind.with_error_location("[ListenServerRef]", "read_as_root", 0) }) } } - /// The table `GetStatsResponse` in the namespace `FBS.PlainTransport` + /// The union `Listen` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `GetStatsResponse` in the file `../worker/fbs/plainTransport.fbs:38` + /// * Union `Listen` in the file `../worker/fbs/webRtcTransport.fbs:14` #[derive( - Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] - pub struct GetStatsResponse { - /// The field `base` in the table `GetStatsResponse` - pub base: ::planus::alloc::boxed::Box, - /// The field `rtcp_mux` in the table `GetStatsResponse` - pub rtcp_mux: bool, - /// The field `comedia` in the table `GetStatsResponse` - pub comedia: bool, - /// The field `tuple` in the table `GetStatsResponse` - pub tuple: ::planus::alloc::boxed::Box, - /// The field `rtcp_tuple` in the table `GetStatsResponse` - pub rtcp_tuple: - ::core::option::Option<::planus::alloc::boxed::Box>, + pub enum Listen { + /// The variant of type `ListenIndividual` in the union `Listen` + ListenIndividual(::planus::alloc::boxed::Box), + + /// The variant of type `ListenServer` in the union `Listen` + ListenServer(::planus::alloc::boxed::Box), } - impl GetStatsResponse { - /// Creates a [GetStatsResponseBuilder] for serializing an instance of this table. + impl Listen { + /// Creates a [ListenBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> GetStatsResponseBuilder<()> { - GetStatsResponseBuilder(()) + pub fn builder() -> ListenBuilder<::planus::Uninitialized> { + ListenBuilder(::planus::Uninitialized) } - #[allow(clippy::too_many_arguments)] - pub fn create( + #[inline] + pub fn create_listen_individual( builder: &mut ::planus::Builder, - field_base: impl ::planus::WriteAs<::planus::Offset>, - field_rtcp_mux: impl ::planus::WriteAsDefault, - field_comedia: impl ::planus::WriteAsDefault, - field_tuple: impl ::planus::WriteAs<::planus::Offset>, - field_rtcp_tuple: impl ::planus::WriteAsOptional< - ::planus::Offset, - >, - ) -> ::planus::Offset { - let prepared_base = field_base.prepare(builder); - let prepared_rtcp_mux = field_rtcp_mux.prepare(builder, &false); - let prepared_comedia = field_comedia.prepare(builder, &false); - let prepared_tuple = field_tuple.prepare(builder); - let prepared_rtcp_tuple = field_rtcp_tuple.prepare(builder); - - let mut table_writer: ::planus::table_writer::TableWriter<14> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(3); - if prepared_rtcp_tuple.is_some() { - table_writer.write_entry::<::planus::Offset>(4); - } - if prepared_rtcp_mux.is_some() { - table_writer.write_entry::(1); - } - if prepared_comedia.is_some() { - table_writer.write_entry::(2); - } - - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_tuple); - if let ::core::option::Option::Some(prepared_rtcp_tuple) = - prepared_rtcp_tuple - { - object_writer.write::<_, _, 4>(&prepared_rtcp_tuple); - } - if let ::core::option::Option::Some(prepared_rtcp_mux) = - prepared_rtcp_mux - { - object_writer.write::<_, _, 1>(&prepared_rtcp_mux); - } - if let ::core::option::Option::Some(prepared_comedia) = prepared_comedia - { - object_writer.write::<_, _, 1>(&prepared_comedia); - } - }); - } - builder.current_offset() + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) } - } - - impl ::planus::WriteAs<::planus::Offset> for GetStatsResponse { - type Prepared = ::planus::Offset; #[inline] - fn prepare( - &self, + pub fn create_listen_server( builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + value: impl ::planus::WriteAsOffset, + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) } } - impl ::planus::WriteAsOptional<::planus::Offset> for GetStatsResponse { - type Prepared = ::planus::Offset; - + impl ::planus::WriteAsUnion for Listen { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { + match self { + Self::ListenIndividual(value) => { + Self::create_listen_individual(builder, value) + } + Self::ListenServer(value) => Self::create_listen_server(builder, value), + } } } - impl ::planus::WriteAsOffset for GetStatsResponse { + impl ::planus::WriteAsOptionalUnion for Listen { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - GetStatsResponse::create( - builder, - &self.base, - self.rtcp_mux, - self.comedia, - &self.tuple, - &self.rtcp_tuple, - ) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - /// Builder for serializing an instance of the [GetStatsResponse] type. + /// Builder for serializing an instance of the [Listen] type. /// - /// Can be created using the [GetStatsResponse::builder] method. + /// Can be created using the [Listen::builder] method. #[derive(Debug)] #[must_use] - pub struct GetStatsResponseBuilder(State); - - impl GetStatsResponseBuilder<()> { - /// Setter for the [`base` field](GetStatsResponse#structfield.base). - #[inline] - #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> GetStatsResponseBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - GetStatsResponseBuilder((value,)) - } - } - - impl GetStatsResponseBuilder<(T0,)> { - /// Setter for the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux). - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux(self, value: T1) -> GetStatsResponseBuilder<(T0, T1)> - where - T1: ::planus::WriteAsDefault, - { - let (v0,) = self.0; - GetStatsResponseBuilder((v0, value)) - } - - /// Sets the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux) to the default value. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_mux_as_default( - self, - ) -> GetStatsResponseBuilder<(T0, ::planus::DefaultValue)> { - self.rtcp_mux(::planus::DefaultValue) - } - } - - impl GetStatsResponseBuilder<(T0, T1)> { - /// Setter for the [`comedia` field](GetStatsResponse#structfield.comedia). - #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia(self, value: T2) -> GetStatsResponseBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsDefault, - { - let (v0, v1) = self.0; - GetStatsResponseBuilder((v0, v1, value)) - } + pub struct ListenBuilder(T); - /// Sets the [`comedia` field](GetStatsResponse#structfield.comedia) to the default value. + impl ListenBuilder<::planus::Uninitialized> { + /// Creates an instance of the [`ListenIndividual` variant](Listen#variant.ListenIndividual). #[inline] - #[allow(clippy::type_complexity)] - pub fn comedia_as_default( + pub fn listen_individual( self, - ) -> GetStatsResponseBuilder<(T0, T1, ::planus::DefaultValue)> { - self.comedia(::planus::DefaultValue) - } - } - - impl GetStatsResponseBuilder<(T0, T1, T2)> { - /// Setter for the [`tuple` field](GetStatsResponse#structfield.tuple). - #[inline] - #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T3) -> GetStatsResponseBuilder<(T0, T1, T2, T3)> + value: T, + ) -> ListenBuilder<::planus::Initialized<1, T>> where - T3: ::planus::WriteAs<::planus::Offset>, + T: ::planus::WriteAsOffset, { - let (v0, v1, v2) = self.0; - GetStatsResponseBuilder((v0, v1, v2, value)) + ListenBuilder(::planus::Initialized(value)) } - } - impl GetStatsResponseBuilder<(T0, T1, T2, T3)> { - /// Setter for the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple). + /// Creates an instance of the [`ListenServer` variant](Listen#variant.ListenServer). #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple( + pub fn listen_server( self, - value: T4, - ) -> GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> + value: T, + ) -> ListenBuilder<::planus::Initialized<2, T>> where - T4: ::planus::WriteAsOptional<::planus::Offset>, + T: ::planus::WriteAsOffset, { - let (v0, v1, v2, v3) = self.0; - GetStatsResponseBuilder((v0, v1, v2, v3, value)) - } - - /// Sets the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple) to null. - #[inline] - #[allow(clippy::type_complexity)] - pub fn rtcp_tuple_as_null(self) -> GetStatsResponseBuilder<(T0, T1, T2, T3, ())> { - self.rtcp_tuple(()) + ListenBuilder(::planus::Initialized(value)) } } - impl GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [GetStatsResponse]. + impl ListenBuilder<::planus::Initialized> { + /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Listen]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::UnionOffset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsUnion, { - ::planus::WriteAsOffset::prepare(&self, builder) + ::planus::WriteAsUnion::prepare(&self, builder) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> + impl ::planus::WriteAsUnion for ListenBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; - #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> + impl ::planus::WriteAsOptionalUnion for ListenBuilder<::planus::Initialized<1, T>> + where + T: ::planus::WriteAsOffset, { - type Prepared = ::planus::Offset; - #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsDefault, - T2: ::planus::WriteAsDefault, - T3: ::planus::WriteAs<::planus::Offset>, - T4: ::planus::WriteAsOptional<::planus::Offset>, - > ::planus::WriteAsOffset - for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> + impl ::planus::WriteAsUnion for ListenBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2, v3, v4) = &self.0; - GetStatsResponse::create(builder, v0, v1, v2, v3, v4) + ) -> ::planus::UnionOffset { + ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) } } - /// Reference to a deserialized [GetStatsResponse]. - #[derive(Copy, Clone)] - pub struct GetStatsResponseRef<'a>(::planus::table_reader::Table<'a>); - - impl<'a> GetStatsResponseRef<'a> { - /// Getter for the [`base` field](GetStatsResponse#structfield.base). - #[inline] - pub fn base(&self) -> ::planus::Result> { - self.0.access_required(0, "GetStatsResponse", "base") - } - - /// Getter for the [`rtcp_mux` field](GetStatsResponse#structfield.rtcp_mux). - #[inline] - pub fn rtcp_mux(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(1, "GetStatsResponse", "rtcp_mux")? - .unwrap_or(false), - ) - } - - /// Getter for the [`comedia` field](GetStatsResponse#structfield.comedia). - #[inline] - pub fn comedia(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "GetStatsResponse", "comedia")? - .unwrap_or(false), - ) - } - - /// Getter for the [`tuple` field](GetStatsResponse#structfield.tuple). - #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(3, "GetStatsResponse", "tuple") - } - - /// Getter for the [`rtcp_tuple` field](GetStatsResponse#structfield.rtcp_tuple). + impl ::planus::WriteAsOptionalUnion for ListenBuilder<::planus::Initialized<2, T>> + where + T: ::planus::WriteAsOffset, + { #[inline] - pub fn rtcp_tuple( + fn prepare( &self, - ) -> ::planus::Result<::core::option::Option>> - { - self.0.access(4, "GetStatsResponse", "rtcp_tuple") + builder: &mut ::planus::Builder, + ) -> ::core::option::Option<::planus::UnionOffset> { + ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) } } - impl<'a> ::core::fmt::Debug for GetStatsResponseRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("GetStatsResponseRef"); - f.field("base", &self.base()); - f.field("rtcp_mux", &self.rtcp_mux()); - f.field("comedia", &self.comedia()); - f.field("tuple", &self.tuple()); - if let ::core::option::Option::Some(field_rtcp_tuple) = - self.rtcp_tuple().transpose() - { - f.field("rtcp_tuple", &field_rtcp_tuple); - } - f.finish() - } + /// Reference to a deserialized [Listen]. + #[derive(Copy, Clone, Debug)] + pub enum ListenRef<'a> { + ListenIndividual(self::ListenIndividualRef<'a>), + ListenServer(self::ListenServerRef<'a>), } - impl<'a> ::core::convert::TryFrom> for GetStatsResponse { + impl<'a> ::core::convert::TryFrom> for Listen { type Error = ::planus::Error; - #[allow(unreachable_code)] - fn try_from(value: GetStatsResponseRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( - value.base()?, - )?), - rtcp_mux: ::core::convert::TryInto::try_into(value.rtcp_mux()?)?, - comedia: ::core::convert::TryInto::try_into(value.comedia()?)?, - tuple: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.tuple()?)?, - ), - rtcp_tuple: if let ::core::option::Option::Some(rtcp_tuple) = - value.rtcp_tuple()? - { - ::core::option::Option::Some(::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(rtcp_tuple)?, + fn try_from(value: ListenRef<'a>) -> ::planus::Result { + ::core::result::Result::Ok(match value { + ListenRef::ListenIndividual(value) => { + Self::ListenIndividual(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, )) - } else { - ::core::option::Option::None - }, + } + + ListenRef::ListenServer(value) => { + Self::ListenServer(::planus::alloc::boxed::Box::new( + ::core::convert::TryFrom::try_from(value)?, + )) + } }) } } - impl<'a> ::planus::TableRead<'a> for GetStatsResponseRef<'a> { - #[inline] + impl<'a> ::planus::TableReadUnion<'a> for ListenRef<'a> { fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, + field_offset: usize, + tag: u8, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) - } - } - - impl<'a> ::planus::VectorReadInner<'a> for GetStatsResponseRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { - error_kind.with_error_location( - "[GetStatsResponseRef]", - "get", - buffer.offset_from_start, - ) - }) - } - } - - impl ::planus::VectorWrite<::planus::Offset> for GetStatsResponse { - type Value = ::planus::Offset; - const STRIDE: usize = 4; - #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) - } - - #[inline] - unsafe fn write_values( - values: &[::planus::Offset], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, - ); + match tag { + 1 => ::core::result::Result::Ok(Self::ListenIndividual( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + 2 => ::core::result::Result::Ok(Self::ListenServer( + ::planus::TableRead::from_buffer(buffer, field_offset)?, + )), + _ => ::core::result::Result::Err( + ::planus::errors::ErrorKind::UnknownUnionTag { tag }, + ), } } } - impl<'a> ::planus::ReadAsRoot<'a> for GetStatsResponseRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[GetStatsResponseRef]", "read_as_root", 0) - }) - } - } - - /// The table `TupleNotification` in the namespace `FBS.PlainTransport` + /// The table `WebRtcTransportOptions` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `TupleNotification` in the file `../worker/fbs/plainTransport.fbs:48` + /// * Table `WebRtcTransportOptions` in the file `../worker/fbs/webRtcTransport.fbs:19` #[derive( Clone, Debug, @@ -73447,182 +74980,223 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct TupleNotification { - /// The field `tuple` in the table `TupleNotification` - pub tuple: ::planus::alloc::boxed::Box, + pub struct WebRtcTransportOptions { + /// The field `base` in the table `WebRtcTransportOptions` + pub base: ::planus::alloc::boxed::Box, + /// The field `listen` in the table `WebRtcTransportOptions` + pub listen: self::Listen, } - impl TupleNotification { - /// Creates a [TupleNotificationBuilder] for serializing an instance of this table. + impl WebRtcTransportOptions { + /// Creates a [WebRtcTransportOptionsBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> TupleNotificationBuilder<()> { - TupleNotificationBuilder(()) + pub fn builder() -> WebRtcTransportOptionsBuilder<()> { + WebRtcTransportOptionsBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_tuple: impl ::planus::WriteAs<::planus::Offset>, + field_base: impl ::planus::WriteAs<::planus::Offset>, + field_listen: impl ::planus::WriteAsUnion, ) -> ::planus::Offset { - let prepared_tuple = field_tuple.prepare(builder); + let prepared_base = field_base.prepare(builder); + let prepared_listen = field_listen.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<10> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(0); + table_writer.write_entry::<::planus::Offset>(2); + table_writer.write_entry::(1); unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_tuple); + object_writer.write::<_, _, 4>(&prepared_base); + object_writer.write::<_, _, 4>(&prepared_listen.offset()); + object_writer.write::<_, _, 1>(&prepared_listen.tag()); }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for TupleNotification { + impl ::planus::WriteAs<::planus::Offset> for WebRtcTransportOptions { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for TupleNotification { + impl ::planus::WriteAsOptional<::planus::Offset> + for WebRtcTransportOptions + { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for TupleNotification { + impl ::planus::WriteAsOffset for WebRtcTransportOptions { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - TupleNotification::create(builder, &self.tuple) + ) -> ::planus::Offset { + WebRtcTransportOptions::create(builder, &self.base, &self.listen) } } - /// Builder for serializing an instance of the [TupleNotification] type. + /// Builder for serializing an instance of the [WebRtcTransportOptions] type. /// - /// Can be created using the [TupleNotification::builder] method. + /// Can be created using the [WebRtcTransportOptions::builder] method. #[derive(Debug)] #[must_use] - pub struct TupleNotificationBuilder(State); + pub struct WebRtcTransportOptionsBuilder(State); - impl TupleNotificationBuilder<()> { - /// Setter for the [`tuple` field](TupleNotification#structfield.tuple). + impl WebRtcTransportOptionsBuilder<()> { + /// Setter for the [`base` field](WebRtcTransportOptions#structfield.base). #[inline] #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T0) -> TupleNotificationBuilder<(T0,)> + pub fn base(self, value: T0) -> WebRtcTransportOptionsBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAs<::planus::Offset>, { - TupleNotificationBuilder((value,)) + WebRtcTransportOptionsBuilder((value,)) } } - impl TupleNotificationBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [TupleNotification]. + impl WebRtcTransportOptionsBuilder<(T0,)> { + /// Setter for the [`listen` field](WebRtcTransportOptions#structfield.listen). + #[inline] + #[allow(clippy::type_complexity)] + pub fn listen(self, value: T1) -> WebRtcTransportOptionsBuilder<(T0, T1)> + where + T1: ::planus::WriteAsUnion, + { + let (v0,) = self.0; + WebRtcTransportOptionsBuilder((v0, value)) + } + } + + impl WebRtcTransportOptionsBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [WebRtcTransportOptions]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } - impl>> - ::planus::WriteAs<::planus::Offset> - for TupleNotificationBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAs<::planus::Offset> + for WebRtcTransportOptionsBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for TupleNotificationBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAsOptional<::planus::Offset> + for WebRtcTransportOptionsBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> + { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl>> - ::planus::WriteAsOffset for TupleNotificationBuilder<(T0,)> + impl< + T0: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsUnion, + > ::planus::WriteAsOffset + for WebRtcTransportOptionsBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - TupleNotification::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + WebRtcTransportOptions::create(builder, v0, v1) } } - /// Reference to a deserialized [TupleNotification]. + /// Reference to a deserialized [WebRtcTransportOptions]. #[derive(Copy, Clone)] - pub struct TupleNotificationRef<'a>(::planus::table_reader::Table<'a>); + pub struct WebRtcTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> TupleNotificationRef<'a> { - /// Getter for the [`tuple` field](TupleNotification#structfield.tuple). + impl<'a> WebRtcTransportOptionsRef<'a> { + /// Getter for the [`base` field](WebRtcTransportOptions#structfield.base). #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(0, "TupleNotification", "tuple") + pub fn base(&self) -> ::planus::Result> { + self.0.access_required(0, "WebRtcTransportOptions", "base") + } + + /// Getter for the [`listen` field](WebRtcTransportOptions#structfield.listen). + #[inline] + pub fn listen(&self) -> ::planus::Result> { + self.0 + .access_union_required(1, "WebRtcTransportOptions", "listen") } } - impl<'a> ::core::fmt::Debug for TupleNotificationRef<'a> { + impl<'a> ::core::fmt::Debug for WebRtcTransportOptionsRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("TupleNotificationRef"); - f.field("tuple", &self.tuple()); + let mut f = f.debug_struct("WebRtcTransportOptionsRef"); + f.field("base", &self.base()); + f.field("listen", &self.listen()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for TupleNotification { + impl<'a> ::core::convert::TryFrom> for WebRtcTransportOptions { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: TupleNotificationRef<'a>) -> ::planus::Result { + fn try_from(value: WebRtcTransportOptionsRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - tuple: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.tuple()?)?, - ), + base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( + value.base()?, + )?), + listen: ::core::convert::TryInto::try_into(value.listen()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for TupleNotificationRef<'a> { + impl<'a> ::planus::TableRead<'a> for WebRtcTransportOptionsRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -73634,7 +75208,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for TupleNotificationRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for WebRtcTransportOptionsRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -73644,7 +75218,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[TupleNotificationRef]", + "[WebRtcTransportOptionsRef]", "get", buffer.offset_from_start, ) @@ -73652,8 +75226,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for TupleNotification { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for WebRtcTransportOptions { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -73662,7 +75236,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -73677,7 +75251,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for TupleNotificationRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for WebRtcTransportOptionsRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -73687,287 +75261,207 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[TupleNotificationRef]", "read_as_root", 0) + error_kind.with_error_location( + "[WebRtcTransportOptionsRef]", + "read_as_root", + 0, + ) }) } } - /// The table `RtcpTupleNotification` in the namespace `FBS.PlainTransport` + /// The enum `FingerprintAlgorithm` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `RtcpTupleNotification` in the file `../worker/fbs/plainTransport.fbs:52` + /// * Enum `FingerprintAlgorithm` in the file `../worker/fbs/webRtcTransport.fbs:24` #[derive( + Copy, Clone, Debug, PartialEq, - PartialOrd, Eq, + PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - pub struct RtcpTupleNotification { - /// The field `tuple` in the table `RtcpTupleNotification` - pub tuple: ::planus::alloc::boxed::Box, - } + #[repr(u8)] + pub enum FingerprintAlgorithm { + /// The variant `SHA1` in the enum `FingerprintAlgorithm` + Sha1 = 0, - impl RtcpTupleNotification { - /// Creates a [RtcpTupleNotificationBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> RtcpTupleNotificationBuilder<()> { - RtcpTupleNotificationBuilder(()) - } + /// The variant `SHA224` in the enum `FingerprintAlgorithm` + Sha224 = 1, - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_tuple: impl ::planus::WriteAs<::planus::Offset>, - ) -> ::planus::Offset { - let prepared_tuple = field_tuple.prepare(builder); + /// The variant `SHA256` in the enum `FingerprintAlgorithm` + Sha256 = 2, - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + /// The variant `SHA384` in the enum `FingerprintAlgorithm` + Sha384 = 3, - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_tuple); - }); - } - builder.current_offset() - } + /// The variant `SHA512` in the enum `FingerprintAlgorithm` + Sha512 = 4, } - impl ::planus::WriteAs<::planus::Offset> for RtcpTupleNotification { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } + impl FingerprintAlgorithm { + /// Array containing all valid variants of FingerprintAlgorithm + pub const ENUM_VALUES: [Self; 5] = [ + Self::Sha1, + Self::Sha224, + Self::Sha256, + Self::Sha384, + Self::Sha512, + ]; } - impl ::planus::WriteAsOptional<::planus::Offset> for RtcpTupleNotification { - type Prepared = ::planus::Offset; - + impl ::core::convert::TryFrom for FingerprintAlgorithm { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> + fn try_from( + value: u8, + ) -> ::core::result::Result { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(FingerprintAlgorithm::Sha1), + 1 => ::core::result::Result::Ok(FingerprintAlgorithm::Sha224), + 2 => ::core::result::Result::Ok(FingerprintAlgorithm::Sha256), + 3 => ::core::result::Result::Ok(FingerprintAlgorithm::Sha384), + 4 => ::core::result::Result::Ok(FingerprintAlgorithm::Sha512), - impl ::planus::WriteAsOffset for RtcpTupleNotification { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - RtcpTupleNotification::create(builder, &self.tuple) + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } } - /// Builder for serializing an instance of the [RtcpTupleNotification] type. - /// - /// Can be created using the [RtcpTupleNotification::builder] method. - #[derive(Debug)] - #[must_use] - pub struct RtcpTupleNotificationBuilder(State); - - impl RtcpTupleNotificationBuilder<()> { - /// Setter for the [`tuple` field](RtcpTupleNotification#structfield.tuple). + impl ::core::convert::From for u8 { #[inline] - #[allow(clippy::type_complexity)] - pub fn tuple(self, value: T0) -> RtcpTupleNotificationBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - RtcpTupleNotificationBuilder((value,)) + fn from(value: FingerprintAlgorithm) -> Self { + value as u8 } } - impl RtcpTupleNotificationBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [RtcpTupleNotification]. - #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) - } + impl ::planus::Primitive for FingerprintAlgorithm { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; } - impl>> - ::planus::WriteAs<::planus::Offset> - for RtcpTupleNotificationBuilder<(T0,)> - { - type Prepared = ::planus::Offset; - + impl ::planus::WriteAsPrimitive for FingerprintAlgorithm { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for RtcpTupleNotificationBuilder<(T0,)> - { - type Prepared = ::planus::Offset; + impl ::planus::WriteAs for FingerprintAlgorithm { + type Prepared = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, _builder: &mut ::planus::Builder) -> FingerprintAlgorithm { + *self } } - impl>> - ::planus::WriteAsOffset - for RtcpTupleNotificationBuilder<(T0,)> - { + impl ::planus::WriteAsDefault for FingerprintAlgorithm { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - RtcpTupleNotification::create(builder, v0) + _builder: &mut ::planus::Builder, + default: &FingerprintAlgorithm, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - /// Reference to a deserialized [RtcpTupleNotification]. - #[derive(Copy, Clone)] - pub struct RtcpTupleNotificationRef<'a>(::planus::table_reader::Table<'a>); + impl ::planus::WriteAsOptional for FingerprintAlgorithm { + type Prepared = Self; - impl<'a> RtcpTupleNotificationRef<'a> { - /// Getter for the [`tuple` field](RtcpTupleNotification#structfield.tuple). #[inline] - pub fn tuple(&self) -> ::planus::Result> { - self.0.access_required(0, "RtcpTupleNotification", "tuple") - } - } - - impl<'a> ::core::fmt::Debug for RtcpTupleNotificationRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("RtcpTupleNotificationRef"); - f.field("tuple", &self.tuple()); - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for RtcpTupleNotification { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: RtcpTupleNotificationRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - tuple: ::planus::alloc::boxed::Box::new( - ::core::convert::TryInto::try_into(value.tuple()?)?, - ), - }) + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl<'a> ::planus::TableRead<'a> for RtcpTupleNotificationRef<'a> { + impl<'buf> ::planus::TableRead<'buf> for FingerprintAlgorithm { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl<'a> ::planus::VectorReadInner<'a> for RtcpTupleNotificationRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - + impl<'buf> ::planus::VectorReadInner<'buf> for FingerprintAlgorithm { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; + #[inline] unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { error_kind.with_error_location( - "[RtcpTupleNotificationRef]", - "get", + "FingerprintAlgorithm", + "VectorRead::from_buffer", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite<::planus::Offset> for RtcpTupleNotification { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for FingerprintAlgorithm { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for RtcpTupleNotificationRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location( - "[RtcpTupleNotificationRef]", - "read_as_root", - 0, - ) - }) - } - } - } - /// The namespace `FBS.WebRtcTransport` - /// - /// Generated from these locations: - /// * File `../worker/fbs/webRtcTransport.fbs` - pub mod web_rtc_transport { - /// The table `ListenIndividual` in the namespace `FBS.WebRtcTransport` + /// The table `Fingerprint` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `ListenIndividual` in the file `../worker/fbs/webRtcTransport.fbs:6` + /// * Table `Fingerprint` in the file `../worker/fbs/webRtcTransport.fbs:32` #[derive( Clone, Debug, @@ -73979,198 +75473,246 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct ListenIndividual { - /// The field `listen_infos` in the table `ListenIndividual` - pub listen_infos: ::planus::alloc::vec::Vec, + pub struct Fingerprint { + /// The field `algorithm` in the table `Fingerprint` + pub algorithm: self::FingerprintAlgorithm, + /// The field `value` in the table `Fingerprint` + pub value: ::planus::alloc::string::String, } - impl ListenIndividual { - /// Creates a [ListenIndividualBuilder] for serializing an instance of this table. + impl Fingerprint { + /// Creates a [FingerprintBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> ListenIndividualBuilder<()> { - ListenIndividualBuilder(()) + pub fn builder() -> FingerprintBuilder<()> { + FingerprintBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_listen_infos: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + field_algorithm: impl ::planus::WriteAsDefault< + self::FingerprintAlgorithm, + self::FingerprintAlgorithm, >, + field_value: impl ::planus::WriteAs<::planus::Offset>, ) -> ::planus::Offset { - let prepared_listen_infos = field_listen_infos.prepare(builder); + let prepared_algorithm = + field_algorithm.prepare(builder, &self::FingerprintAlgorithm::Sha1); + let prepared_value = field_value.prepare(builder); - let mut table_writer: ::planus::table_writer::TableWriter<6> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset<[::planus::Offset]>>(0); + table_writer.write_entry::<::planus::Offset>(1); + if prepared_algorithm.is_some() { + table_writer.write_entry::(0); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_listen_infos); + object_writer.write::<_, _, 4>(&prepared_value); + if let ::core::option::Option::Some(prepared_algorithm) = + prepared_algorithm + { + object_writer.write::<_, _, 1>(&prepared_algorithm); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for ListenIndividual { + impl ::planus::WriteAs<::planus::Offset> for Fingerprint { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for ListenIndividual { + impl ::planus::WriteAsOptional<::planus::Offset> for Fingerprint { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for ListenIndividual { + impl ::planus::WriteAsOffset for Fingerprint { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ListenIndividual::create(builder, &self.listen_infos) + ) -> ::planus::Offset { + Fingerprint::create(builder, self.algorithm, &self.value) } } - /// Builder for serializing an instance of the [ListenIndividual] type. + /// Builder for serializing an instance of the [Fingerprint] type. /// - /// Can be created using the [ListenIndividual::builder] method. + /// Can be created using the [Fingerprint::builder] method. #[derive(Debug)] #[must_use] - pub struct ListenIndividualBuilder(State); + pub struct FingerprintBuilder(State); - impl ListenIndividualBuilder<()> { - /// Setter for the [`listen_infos` field](ListenIndividual#structfield.listen_infos). + impl FingerprintBuilder<()> { + /// Setter for the [`algorithm` field](Fingerprint#structfield.algorithm). #[inline] #[allow(clippy::type_complexity)] - pub fn listen_infos(self, value: T0) -> ListenIndividualBuilder<(T0,)> + pub fn algorithm(self, value: T0) -> FingerprintBuilder<(T0,)> where - T0: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T0: ::planus::WriteAsDefault< + self::FingerprintAlgorithm, + self::FingerprintAlgorithm, >, { - ListenIndividualBuilder((value,)) + FingerprintBuilder((value,)) + } + + /// Sets the [`algorithm` field](Fingerprint#structfield.algorithm) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn algorithm_as_default(self) -> FingerprintBuilder<(::planus::DefaultValue,)> { + self.algorithm(::planus::DefaultValue) } } - impl ListenIndividualBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ListenIndividual]. + impl FingerprintBuilder<(T0,)> { + /// Setter for the [`value` field](Fingerprint#structfield.value). + #[inline] + #[allow(clippy::type_complexity)] + pub fn value(self, value: T1) -> FingerprintBuilder<(T0, T1)> + where + T1: ::planus::WriteAs<::planus::Offset>, + { + let (v0,) = self.0; + FingerprintBuilder((v0, value)) + } + } + + impl FingerprintBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Fingerprint]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T0: ::planus::WriteAsDefault< + self::FingerprintAlgorithm, + self::FingerprintAlgorithm, >, - > ::planus::WriteAs<::planus::Offset> - for ListenIndividualBuilder<(T0,)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAs<::planus::Offset> + for FingerprintBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T0: ::planus::WriteAsDefault< + self::FingerprintAlgorithm, + self::FingerprintAlgorithm, >, - > ::planus::WriteAsOptional<::planus::Offset> - for ListenIndividualBuilder<(T0,)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOptional<::planus::Offset> + for FingerprintBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, + T0: ::planus::WriteAsDefault< + self::FingerprintAlgorithm, + self::FingerprintAlgorithm, >, - > ::planus::WriteAsOffset for ListenIndividualBuilder<(T0,)> + T1: ::planus::WriteAs<::planus::Offset>, + > ::planus::WriteAsOffset for FingerprintBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - ListenIndividual::create(builder, v0) + ) -> ::planus::Offset { + let (v0, v1) = &self.0; + Fingerprint::create(builder, v0, v1) } } - /// Reference to a deserialized [ListenIndividual]. + /// Reference to a deserialized [Fingerprint]. #[derive(Copy, Clone)] - pub struct ListenIndividualRef<'a>(::planus::table_reader::Table<'a>); + pub struct FingerprintRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> ListenIndividualRef<'a> { - /// Getter for the [`listen_infos` field](ListenIndividual#structfield.listen_infos). + impl<'a> FingerprintRef<'a> { + /// Getter for the [`algorithm` field](Fingerprint#structfield.algorithm). #[inline] - pub fn listen_infos( - &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0 - .access_required(0, "ListenIndividual", "listen_infos") + pub fn algorithm(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "Fingerprint", "algorithm")? + .unwrap_or(self::FingerprintAlgorithm::Sha1), + ) + } + + /// Getter for the [`value` field](Fingerprint#structfield.value). + #[inline] + pub fn value(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(1, "Fingerprint", "value") } } - impl<'a> ::core::fmt::Debug for ListenIndividualRef<'a> { + impl<'a> ::core::fmt::Debug for FingerprintRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ListenIndividualRef"); - f.field("listen_infos", &self.listen_infos()); + let mut f = f.debug_struct("FingerprintRef"); + f.field("algorithm", &self.algorithm()); + f.field("value", &self.value()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for ListenIndividual { + impl<'a> ::core::convert::TryFrom> for Fingerprint { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: ListenIndividualRef<'a>) -> ::planus::Result { + fn try_from(value: FingerprintRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - listen_infos: value.listen_infos()?.to_vec_result()?, + algorithm: ::core::convert::TryInto::try_into(value.algorithm()?)?, + value: ::core::convert::TryInto::try_into(value.value()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for ListenIndividualRef<'a> { + impl<'a> ::planus::TableRead<'a> for FingerprintRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -74182,7 +75724,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for ListenIndividualRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for FingerprintRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -74192,7 +75734,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[ListenIndividualRef]", + "[FingerprintRef]", "get", buffer.offset_from_start, ) @@ -74200,8 +75742,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for ListenIndividual { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for Fingerprint { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -74210,7 +75752,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -74225,7 +75767,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for ListenIndividualRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for FingerprintRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -74235,489 +75777,377 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[ListenIndividualRef]", "read_as_root", 0) + error_kind.with_error_location("[FingerprintRef]", "read_as_root", 0) }) } } - /// The table `ListenServer` in the namespace `FBS.WebRtcTransport` + /// The enum `DtlsRole` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `ListenServer` in the file `../worker/fbs/webRtcTransport.fbs:10` + /// * Enum `DtlsRole` in the file `../worker/fbs/webRtcTransport.fbs:37` #[derive( + Copy, Clone, Debug, PartialEq, - PartialOrd, Eq, + PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - pub struct ListenServer { - /// The field `web_rtc_server_id` in the table `ListenServer` - pub web_rtc_server_id: ::planus::alloc::string::String, - } - - impl ListenServer { - /// Creates a [ListenServerBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> ListenServerBuilder<()> { - ListenServerBuilder(()) - } - - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_web_rtc_server_id: impl ::planus::WriteAs<::planus::Offset>, - ) -> ::planus::Offset { - let prepared_web_rtc_server_id = field_web_rtc_server_id.prepare(builder); + #[repr(u8)] + pub enum DtlsRole { + /// The variant `AUTO` in the enum `DtlsRole` + Auto = 0, - let mut table_writer: ::planus::table_writer::TableWriter<6> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + /// The variant `CLIENT` in the enum `DtlsRole` + Client = 1, - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_web_rtc_server_id); - }); - } - builder.current_offset() - } + /// The variant `SERVER` in the enum `DtlsRole` + Server = 2, } - impl ::planus::WriteAs<::planus::Offset> for ListenServer { - type Prepared = ::planus::Offset; - - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } + impl DtlsRole { + /// Array containing all valid variants of DtlsRole + pub const ENUM_VALUES: [Self; 3] = [Self::Auto, Self::Client, Self::Server]; } - impl ::planus::WriteAsOptional<::planus::Offset> for ListenServer { - type Prepared = ::planus::Offset; - + impl ::core::convert::TryFrom for DtlsRole { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) - } - } + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(DtlsRole::Auto), + 1 => ::core::result::Result::Ok(DtlsRole::Client), + 2 => ::core::result::Result::Ok(DtlsRole::Server), - impl ::planus::WriteAsOffset for ListenServer { - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ListenServer::create(builder, &self.web_rtc_server_id) + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } } - /// Builder for serializing an instance of the [ListenServer] type. - /// - /// Can be created using the [ListenServer::builder] method. - #[derive(Debug)] - #[must_use] - pub struct ListenServerBuilder(State); - - impl ListenServerBuilder<()> { - /// Setter for the [`web_rtc_server_id` field](ListenServer#structfield.web_rtc_server_id). + impl ::core::convert::From for u8 { #[inline] - #[allow(clippy::type_complexity)] - pub fn web_rtc_server_id(self, value: T0) -> ListenServerBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - ListenServerBuilder((value,)) + fn from(value: DtlsRole) -> Self { + value as u8 } } - impl ListenServerBuilder<(T0,)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [ListenServer]. - #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) - } + impl ::planus::Primitive for DtlsRole { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; } - impl>> - ::planus::WriteAs<::planus::Offset> for ListenServerBuilder<(T0,)> - { - type Prepared = ::planus::Offset; - + impl ::planus::WriteAsPrimitive for DtlsRole { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl>> - ::planus::WriteAsOptional<::planus::Offset> - for ListenServerBuilder<(T0,)> - { - type Prepared = ::planus::Offset; + impl ::planus::WriteAs for DtlsRole { + type Prepared = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, _builder: &mut ::planus::Builder) -> DtlsRole { + *self } } - impl>> ::planus::WriteAsOffset - for ListenServerBuilder<(T0,)> - { + impl ::planus::WriteAsDefault for DtlsRole { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0,) = &self.0; - ListenServer::create(builder, v0) + _builder: &mut ::planus::Builder, + default: &DtlsRole, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - /// Reference to a deserialized [ListenServer]. - #[derive(Copy, Clone)] - pub struct ListenServerRef<'a>(::planus::table_reader::Table<'a>); + impl ::planus::WriteAsOptional for DtlsRole { + type Prepared = Self; - impl<'a> ListenServerRef<'a> { - /// Getter for the [`web_rtc_server_id` field](ListenServer#structfield.web_rtc_server_id). #[inline] - pub fn web_rtc_server_id(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "ListenServer", "web_rtc_server_id") - } - } - - impl<'a> ::core::fmt::Debug for ListenServerRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("ListenServerRef"); - f.field("web_rtc_server_id", &self.web_rtc_server_id()); - f.finish() - } - } - - impl<'a> ::core::convert::TryFrom> for ListenServer { - type Error = ::planus::Error; - - #[allow(unreachable_code)] - fn try_from(value: ListenServerRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - web_rtc_server_id: ::core::convert::TryInto::try_into( - value.web_rtc_server_id()?, - )?, - }) + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl<'a> ::planus::TableRead<'a> for ListenServerRef<'a> { + impl<'buf> ::planus::TableRead<'buf> for DtlsRole { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl<'a> ::planus::VectorReadInner<'a> for ListenServerRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - + impl<'buf> ::planus::VectorReadInner<'buf> for DtlsRole { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; + #[inline] unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { error_kind.with_error_location( - "[ListenServerRef]", - "get", + "DtlsRole", + "VectorRead::from_buffer", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite<::planus::Offset> for ListenServer { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for DtlsRole { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for ListenServerRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[ListenServerRef]", "read_as_root", 0) - }) - } - } - - /// The union `Listen` in the namespace `FBS.WebRtcTransport` + /// The enum `DtlsState` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Union `Listen` in the file `../worker/fbs/webRtcTransport.fbs:14` + /// * Enum `DtlsState` in the file `../worker/fbs/webRtcTransport.fbs:43` #[derive( + Copy, Clone, Debug, PartialEq, - PartialOrd, Eq, + PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - pub enum Listen { - /// The variant of type `ListenIndividual` in the union `Listen` - ListenIndividual(::planus::alloc::boxed::Box), + #[repr(u8)] + pub enum DtlsState { + /// The variant `NEW` in the enum `DtlsState` + New = 0, - /// The variant of type `ListenServer` in the union `Listen` - ListenServer(::planus::alloc::boxed::Box), - } + /// The variant `CONNECTING` in the enum `DtlsState` + Connecting = 1, - impl Listen { - /// Creates a [ListenBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> ListenBuilder<::planus::Uninitialized> { - ListenBuilder(::planus::Uninitialized) - } + /// The variant `CONNECTED` in the enum `DtlsState` + Connected = 2, - #[inline] - pub fn create_listen_individual( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, value.prepare(builder).downcast()) - } + /// The variant `FAILED` in the enum `DtlsState` + Failed = 3, - #[inline] - pub fn create_listen_server( - builder: &mut ::planus::Builder, - value: impl ::planus::WriteAsOffset, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, value.prepare(builder).downcast()) - } + /// The variant `CLOSED` in the enum `DtlsState` + Closed = 4, + } + + impl DtlsState { + /// Array containing all valid variants of DtlsState + pub const ENUM_VALUES: [Self; 5] = [ + Self::New, + Self::Connecting, + Self::Connected, + Self::Failed, + Self::Closed, + ]; } - impl ::planus::WriteAsUnion for Listen { + impl ::core::convert::TryFrom for DtlsState { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset { - match self { - Self::ListenIndividual(value) => { - Self::create_listen_individual(builder, value) - } - Self::ListenServer(value) => Self::create_listen_server(builder, value), + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(DtlsState::New), + 1 => ::core::result::Result::Ok(DtlsState::Connecting), + 2 => ::core::result::Result::Ok(DtlsState::Connected), + 3 => ::core::result::Result::Ok(DtlsState::Failed), + 4 => ::core::result::Result::Ok(DtlsState::Closed), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), } } } - impl ::planus::WriteAsOptionalUnion for Listen { + impl ::core::convert::From for u8 { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + fn from(value: DtlsState) -> Self { + value as u8 } } - /// Builder for serializing an instance of the [Listen] type. - /// - /// Can be created using the [Listen::builder] method. - #[derive(Debug)] - #[must_use] - pub struct ListenBuilder(T); - - impl ListenBuilder<::planus::Uninitialized> { - /// Creates an instance of the [`ListenIndividual` variant](Listen#variant.ListenIndividual). - #[inline] - pub fn listen_individual( - self, - value: T, - ) -> ListenBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { - ListenBuilder(::planus::Initialized(value)) - } + impl ::planus::Primitive for DtlsState { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } - /// Creates an instance of the [`ListenServer` variant](Listen#variant.ListenServer). + impl ::planus::WriteAsPrimitive for DtlsState { #[inline] - pub fn listen_server( - self, - value: T, - ) -> ListenBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { - ListenBuilder(::planus::Initialized(value)) + fn write( + &self, + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl ListenBuilder<::planus::Initialized> { - /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [Listen]. + impl ::planus::WriteAs for DtlsState { + type Prepared = Self; + #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset - where - Self: ::planus::WriteAsUnion, - { - ::planus::WriteAsUnion::prepare(&self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> DtlsState { + *self } } - impl ::planus::WriteAsUnion for ListenBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsDefault for DtlsState { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(1, (self.0).0.prepare(builder).downcast()) + _builder: &mut ::planus::Builder, + default: &DtlsState, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - impl ::planus::WriteAsOptionalUnion for ListenBuilder<::planus::Initialized<1, T>> - where - T: ::planus::WriteAsOffset, - { + impl ::planus::WriteAsOptional for DtlsState { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl ::planus::WriteAsUnion for ListenBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { + + impl<'buf> ::planus::TableRead<'buf> for DtlsState { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::UnionOffset { - ::planus::UnionOffset::new(2, (self.0).0.prepare(builder).downcast()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl ::planus::WriteAsOptionalUnion for ListenBuilder<::planus::Initialized<2, T>> - where - T: ::planus::WriteAsOffset, - { + impl<'buf> ::planus::VectorReadInner<'buf> for DtlsState { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::UnionOffset> { - ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder)) + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "DtlsState", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } } - /// Reference to a deserialized [Listen]. - #[derive(Copy, Clone, Debug)] - pub enum ListenRef<'a> { - ListenIndividual(self::ListenIndividualRef<'a>), - ListenServer(self::ListenServerRef<'a>), - } - - impl<'a> ::core::convert::TryFrom> for Listen { - type Error = ::planus::Error; + impl ::planus::VectorWrite for DtlsState { + const STRIDE: usize = 1; - fn try_from(value: ListenRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(match value { - ListenRef::ListenIndividual(value) => { - Self::ListenIndividual(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } + type Value = Self; - ListenRef::ListenServer(value) => { - Self::ListenServer(::planus::alloc::boxed::Box::new( - ::core::convert::TryFrom::try_from(value)?, - )) - } - }) + #[inline] + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } - } - impl<'a> ::planus::TableReadUnion<'a> for ListenRef<'a> { - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, - field_offset: usize, - tag: u8, - ) -> ::core::result::Result { - match tag { - 1 => ::core::result::Result::Ok(Self::ListenIndividual( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - 2 => ::core::result::Result::Ok(Self::ListenServer( - ::planus::TableRead::from_buffer(buffer, field_offset)?, - )), - _ => ::core::result::Result::Err( - ::planus::errors::ErrorKind::UnknownUnionTag { tag }, - ), + #[inline] + unsafe fn write_values( + values: &[Self], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - i as u32, + ); } } } - /// The table `WebRtcTransportOptions` in the namespace `FBS.WebRtcTransport` + /// The table `DtlsParameters` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `WebRtcTransportOptions` in the file `../worker/fbs/webRtcTransport.fbs:19` + /// * Table `DtlsParameters` in the file `../worker/fbs/webRtcTransport.fbs:51` #[derive( Clone, Debug, @@ -74729,223 +76159,237 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct WebRtcTransportOptions { - /// The field `base` in the table `WebRtcTransportOptions` - pub base: ::planus::alloc::boxed::Box, - /// The field `listen` in the table `WebRtcTransportOptions` - pub listen: self::Listen, + pub struct DtlsParameters { + /// The field `fingerprints` in the table `DtlsParameters` + pub fingerprints: ::planus::alloc::vec::Vec, + /// The field `role` in the table `DtlsParameters` + pub role: self::DtlsRole, } - impl WebRtcTransportOptions { - /// Creates a [WebRtcTransportOptionsBuilder] for serializing an instance of this table. + impl DtlsParameters { + /// Creates a [DtlsParametersBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> WebRtcTransportOptionsBuilder<()> { - WebRtcTransportOptionsBuilder(()) + pub fn builder() -> DtlsParametersBuilder<()> { + DtlsParametersBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_base: impl ::planus::WriteAs<::planus::Offset>, - field_listen: impl ::planus::WriteAsUnion, + field_fingerprints: impl ::planus::WriteAs< + ::planus::Offset<[::planus::Offset]>, + >, + field_role: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_base = field_base.prepare(builder); - let prepared_listen = field_listen.prepare(builder); + let prepared_fingerprints = field_fingerprints.prepare(builder); + let prepared_role = field_role.prepare(builder, &self::DtlsRole::Auto); - let mut table_writer: ::planus::table_writer::TableWriter<10> = + let mut table_writer: ::planus::table_writer::TableWriter<8> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(2); - table_writer.write_entry::(1); + table_writer + .write_entry::<::planus::Offset<[::planus::Offset]>>(0); + if prepared_role.is_some() { + table_writer.write_entry::(1); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_listen.offset()); - object_writer.write::<_, _, 1>(&prepared_listen.tag()); + object_writer.write::<_, _, 4>(&prepared_fingerprints); + if let ::core::option::Option::Some(prepared_role) = prepared_role { + object_writer.write::<_, _, 1>(&prepared_role); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for WebRtcTransportOptions { + impl ::planus::WriteAs<::planus::Offset> for DtlsParameters { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> - for WebRtcTransportOptions - { + impl ::planus::WriteAsOptional<::planus::Offset> for DtlsParameters { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for WebRtcTransportOptions { + impl ::planus::WriteAsOffset for DtlsParameters { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - WebRtcTransportOptions::create(builder, &self.base, &self.listen) + ) -> ::planus::Offset { + DtlsParameters::create(builder, &self.fingerprints, self.role) } } - /// Builder for serializing an instance of the [WebRtcTransportOptions] type. + /// Builder for serializing an instance of the [DtlsParameters] type. /// - /// Can be created using the [WebRtcTransportOptions::builder] method. + /// Can be created using the [DtlsParameters::builder] method. #[derive(Debug)] #[must_use] - pub struct WebRtcTransportOptionsBuilder(State); + pub struct DtlsParametersBuilder(State); - impl WebRtcTransportOptionsBuilder<()> { - /// Setter for the [`base` field](WebRtcTransportOptions#structfield.base). + impl DtlsParametersBuilder<()> { + /// Setter for the [`fingerprints` field](DtlsParameters#structfield.fingerprints). #[inline] #[allow(clippy::type_complexity)] - pub fn base(self, value: T0) -> WebRtcTransportOptionsBuilder<(T0,)> + pub fn fingerprints(self, value: T0) -> DtlsParametersBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, { - WebRtcTransportOptionsBuilder((value,)) + DtlsParametersBuilder((value,)) } } - impl WebRtcTransportOptionsBuilder<(T0,)> { - /// Setter for the [`listen` field](WebRtcTransportOptions#structfield.listen). + impl DtlsParametersBuilder<(T0,)> { + /// Setter for the [`role` field](DtlsParameters#structfield.role). #[inline] #[allow(clippy::type_complexity)] - pub fn listen(self, value: T1) -> WebRtcTransportOptionsBuilder<(T0, T1)> + pub fn role(self, value: T1) -> DtlsParametersBuilder<(T0, T1)> where - T1: ::planus::WriteAsUnion, + T1: ::planus::WriteAsDefault, { let (v0,) = self.0; - WebRtcTransportOptionsBuilder((v0, value)) + DtlsParametersBuilder((v0, value)) + } + + /// Sets the [`role` field](DtlsParameters#structfield.role) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn role_as_default( + self, + ) -> DtlsParametersBuilder<(T0, ::planus::DefaultValue)> { + self.role(::planus::DefaultValue) } } - impl WebRtcTransportOptionsBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [WebRtcTransportOptions]. + impl DtlsParametersBuilder<(T0, T1)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DtlsParameters]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAs<::planus::Offset> - for WebRtcTransportOptionsBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> + for DtlsParametersBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAsOptional<::planus::Offset> - for WebRtcTransportOptionsBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for DtlsParametersBuilder<(T0, T1)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> - { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAsUnion, - > ::planus::WriteAsOffset - for WebRtcTransportOptionsBuilder<(T0, T1)> + T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, + T1: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset for DtlsParametersBuilder<(T0, T1)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { let (v0, v1) = &self.0; - WebRtcTransportOptions::create(builder, v0, v1) + DtlsParameters::create(builder, v0, v1) } } - /// Reference to a deserialized [WebRtcTransportOptions]. + /// Reference to a deserialized [DtlsParameters]. #[derive(Copy, Clone)] - pub struct WebRtcTransportOptionsRef<'a>(::planus::table_reader::Table<'a>); + pub struct DtlsParametersRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> WebRtcTransportOptionsRef<'a> { - /// Getter for the [`base` field](WebRtcTransportOptions#structfield.base). + impl<'a> DtlsParametersRef<'a> { + /// Getter for the [`fingerprints` field](DtlsParameters#structfield.fingerprints). #[inline] - pub fn base(&self) -> ::planus::Result> { - self.0.access_required(0, "WebRtcTransportOptions", "base") + pub fn fingerprints( + &self, + ) -> ::planus::Result< + ::planus::Vector<'a, ::planus::Result>>, + > { + self.0.access_required(0, "DtlsParameters", "fingerprints") } - /// Getter for the [`listen` field](WebRtcTransportOptions#structfield.listen). + /// Getter for the [`role` field](DtlsParameters#structfield.role). #[inline] - pub fn listen(&self) -> ::planus::Result> { - self.0 - .access_union_required(1, "WebRtcTransportOptions", "listen") + pub fn role(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "DtlsParameters", "role")? + .unwrap_or(self::DtlsRole::Auto), + ) } } - impl<'a> ::core::fmt::Debug for WebRtcTransportOptionsRef<'a> { + impl<'a> ::core::fmt::Debug for DtlsParametersRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("WebRtcTransportOptionsRef"); - f.field("base", &self.base()); - f.field("listen", &self.listen()); + let mut f = f.debug_struct("DtlsParametersRef"); + f.field("fingerprints", &self.fingerprints()); + f.field("role", &self.role()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for WebRtcTransportOptions { + impl<'a> ::core::convert::TryFrom> for DtlsParameters { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: WebRtcTransportOptionsRef<'a>) -> ::planus::Result { + fn try_from(value: DtlsParametersRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - base: ::planus::alloc::boxed::Box::new(::core::convert::TryInto::try_into( - value.base()?, - )?), - listen: ::core::convert::TryInto::try_into(value.listen()?)?, + fingerprints: value.fingerprints()?.to_vec_result()?, + role: ::core::convert::TryInto::try_into(value.role()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for WebRtcTransportOptionsRef<'a> { + impl<'a> ::planus::TableRead<'a> for DtlsParametersRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -74957,7 +76401,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for WebRtcTransportOptionsRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for DtlsParametersRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -74967,7 +76411,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[WebRtcTransportOptionsRef]", + "[DtlsParametersRef]", "get", buffer.offset_from_start, ) @@ -74975,8 +76419,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for WebRtcTransportOptions { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for DtlsParameters { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -74985,7 +76429,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -75000,7 +76444,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for WebRtcTransportOptionsRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for DtlsParametersRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -75010,19 +76454,15 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location( - "[WebRtcTransportOptionsRef]", - "read_as_root", - 0, - ) + error_kind.with_error_location("[DtlsParametersRef]", "read_as_root", 0) }) } } - /// The table `Fingerprint` in the namespace `FBS.WebRtcTransport` + /// The table `IceParameters` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `Fingerprint` in the file `../worker/fbs/webRtcTransport.fbs:24` + /// * Table `IceParameters` in the file `../worker/fbs/webRtcTransport.fbs:56` #[derive( Clone, Debug, @@ -75034,119 +76474,158 @@ mod root { ::serde::Serialize, ::serde::Deserialize, )] - pub struct Fingerprint { - /// The field `algorithm` in the table `Fingerprint` - pub algorithm: ::planus::alloc::string::String, - /// The field `value` in the table `Fingerprint` - pub value: ::planus::alloc::string::String, + pub struct IceParameters { + /// The field `username_fragment` in the table `IceParameters` + pub username_fragment: ::planus::alloc::string::String, + /// The field `password` in the table `IceParameters` + pub password: ::planus::alloc::string::String, + /// The field `ice_lite` in the table `IceParameters` + pub ice_lite: bool, } - impl Fingerprint { - /// Creates a [FingerprintBuilder] for serializing an instance of this table. + impl IceParameters { + /// Creates a [IceParametersBuilder] for serializing an instance of this table. #[inline] - pub fn builder() -> FingerprintBuilder<()> { - FingerprintBuilder(()) + pub fn builder() -> IceParametersBuilder<()> { + IceParametersBuilder(()) } #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_algorithm: impl ::planus::WriteAs<::planus::Offset>, - field_value: impl ::planus::WriteAs<::planus::Offset>, + field_username_fragment: impl ::planus::WriteAs<::planus::Offset>, + field_password: impl ::planus::WriteAs<::planus::Offset>, + field_ice_lite: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_algorithm = field_algorithm.prepare(builder); - let prepared_value = field_value.prepare(builder); + let prepared_username_fragment = field_username_fragment.prepare(builder); + let prepared_password = field_password.prepare(builder); + let prepared_ice_lite = field_ice_lite.prepare(builder, &true); - let mut table_writer: ::planus::table_writer::TableWriter<8> = + let mut table_writer: ::planus::table_writer::TableWriter<10> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); table_writer.write_entry::<::planus::Offset>(1); + if prepared_ice_lite.is_some() { + table_writer.write_entry::(2); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_algorithm); - object_writer.write::<_, _, 4>(&prepared_value); + object_writer.write::<_, _, 4>(&prepared_username_fragment); + object_writer.write::<_, _, 4>(&prepared_password); + if let ::core::option::Option::Some(prepared_ice_lite) = + prepared_ice_lite + { + object_writer.write::<_, _, 1>(&prepared_ice_lite); + } }); } builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for Fingerprint { + impl ::planus::WriteAs<::planus::Offset> for IceParameters { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } - impl ::planus::WriteAsOptional<::planus::Offset> for Fingerprint { + impl ::planus::WriteAsOptional<::planus::Offset> for IceParameters { type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } - impl ::planus::WriteAsOffset for Fingerprint { + impl ::planus::WriteAsOffset for IceParameters { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - Fingerprint::create(builder, &self.algorithm, &self.value) + ) -> ::planus::Offset { + IceParameters::create( + builder, + &self.username_fragment, + &self.password, + self.ice_lite, + ) } } - /// Builder for serializing an instance of the [Fingerprint] type. + /// Builder for serializing an instance of the [IceParameters] type. /// - /// Can be created using the [Fingerprint::builder] method. + /// Can be created using the [IceParameters::builder] method. #[derive(Debug)] #[must_use] - pub struct FingerprintBuilder(State); + pub struct IceParametersBuilder(State); - impl FingerprintBuilder<()> { - /// Setter for the [`algorithm` field](Fingerprint#structfield.algorithm). + impl IceParametersBuilder<()> { + /// Setter for the [`username_fragment` field](IceParameters#structfield.username_fragment). #[inline] #[allow(clippy::type_complexity)] - pub fn algorithm(self, value: T0) -> FingerprintBuilder<(T0,)> + pub fn username_fragment(self, value: T0) -> IceParametersBuilder<(T0,)> where T0: ::planus::WriteAs<::planus::Offset>, { - FingerprintBuilder((value,)) + IceParametersBuilder((value,)) } } - impl FingerprintBuilder<(T0,)> { - /// Setter for the [`value` field](Fingerprint#structfield.value). + impl IceParametersBuilder<(T0,)> { + /// Setter for the [`password` field](IceParameters#structfield.password). #[inline] #[allow(clippy::type_complexity)] - pub fn value(self, value: T1) -> FingerprintBuilder<(T0, T1)> + pub fn password(self, value: T1) -> IceParametersBuilder<(T0, T1)> where T1: ::planus::WriteAs<::planus::Offset>, { let (v0,) = self.0; - FingerprintBuilder((v0, value)) + IceParametersBuilder((v0, value)) + } + } + + impl IceParametersBuilder<(T0, T1)> { + /// Setter for the [`ice_lite` field](IceParameters#structfield.ice_lite). + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_lite(self, value: T2) -> IceParametersBuilder<(T0, T1, T2)> + where + T2: ::planus::WriteAsDefault, + { + let (v0, v1) = self.0; + IceParametersBuilder((v0, v1, value)) + } + + /// Sets the [`ice_lite` field](IceParameters#structfield.ice_lite) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_lite_as_default( + self, + ) -> IceParametersBuilder<(T0, T1, ::planus::DefaultValue)> { + self.ice_lite(::planus::DefaultValue) } } - impl FingerprintBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [Fingerprint]. + impl IceParametersBuilder<(T0, T1, T2)> { + /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IceParameters]. #[inline] pub fn finish( self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset + ) -> ::planus::Offset where - Self: ::planus::WriteAsOffset, + Self: ::planus::WriteAsOffset, { ::planus::WriteAsOffset::prepare(&self, builder) } @@ -75155,16 +76634,17 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAs<::planus::Offset> - for FingerprintBuilder<(T0, T1)> + T2: ::planus::WriteAsDefault, + > ::planus::WriteAs<::planus::Offset> + for IceParametersBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { + ) -> ::planus::Offset { ::planus::WriteAsOffset::prepare(self, builder) } } @@ -75172,16 +76652,17 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOptional<::planus::Offset> - for FingerprintBuilder<(T0, T1)> + T2: ::planus::WriteAsDefault, + > ::planus::WriteAsOptional<::planus::Offset> + for IceParametersBuilder<(T0, T1, T2)> { - type Prepared = ::planus::Offset; + type Prepared = ::planus::Offset; #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { + ) -> ::core::option::Option<::planus::Offset> { ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) } } @@ -75189,58 +76670,74 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, T1: ::planus::WriteAs<::planus::Offset>, - > ::planus::WriteAsOffset for FingerprintBuilder<(T0, T1)> + T2: ::planus::WriteAsDefault, + > ::planus::WriteAsOffset for IceParametersBuilder<(T0, T1, T2)> { #[inline] fn prepare( &self, builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - Fingerprint::create(builder, v0, v1) + ) -> ::planus::Offset { + let (v0, v1, v2) = &self.0; + IceParameters::create(builder, v0, v1, v2) } } - /// Reference to a deserialized [Fingerprint]. + /// Reference to a deserialized [IceParameters]. #[derive(Copy, Clone)] - pub struct FingerprintRef<'a>(::planus::table_reader::Table<'a>); + pub struct IceParametersRef<'a>(::planus::table_reader::Table<'a>); - impl<'a> FingerprintRef<'a> { - /// Getter for the [`algorithm` field](Fingerprint#structfield.algorithm). + impl<'a> IceParametersRef<'a> { + /// Getter for the [`username_fragment` field](IceParameters#structfield.username_fragment). #[inline] - pub fn algorithm(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(0, "Fingerprint", "algorithm") + pub fn username_fragment(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0 + .access_required(0, "IceParameters", "username_fragment") } - /// Getter for the [`value` field](Fingerprint#structfield.value). + /// Getter for the [`password` field](IceParameters#structfield.password). #[inline] - pub fn value(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(1, "Fingerprint", "value") + pub fn password(&self) -> ::planus::Result<&'a ::core::primitive::str> { + self.0.access_required(1, "IceParameters", "password") + } + + /// Getter for the [`ice_lite` field](IceParameters#structfield.ice_lite). + #[inline] + pub fn ice_lite(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(2, "IceParameters", "ice_lite")? + .unwrap_or(true), + ) } } - impl<'a> ::core::fmt::Debug for FingerprintRef<'a> { + impl<'a> ::core::fmt::Debug for IceParametersRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("FingerprintRef"); - f.field("algorithm", &self.algorithm()); - f.field("value", &self.value()); + let mut f = f.debug_struct("IceParametersRef"); + f.field("username_fragment", &self.username_fragment()); + f.field("password", &self.password()); + f.field("ice_lite", &self.ice_lite()); f.finish() } } - impl<'a> ::core::convert::TryFrom> for Fingerprint { + impl<'a> ::core::convert::TryFrom> for IceParameters { type Error = ::planus::Error; #[allow(unreachable_code)] - fn try_from(value: FingerprintRef<'a>) -> ::planus::Result { + fn try_from(value: IceParametersRef<'a>) -> ::planus::Result { ::core::result::Result::Ok(Self { - algorithm: ::core::convert::TryInto::try_into(value.algorithm()?)?, - value: ::core::convert::TryInto::try_into(value.value()?)?, + username_fragment: ::core::convert::TryInto::try_into( + value.username_fragment()?, + )?, + password: ::core::convert::TryInto::try_into(value.password()?)?, + ice_lite: ::core::convert::TryInto::try_into(value.ice_lite()?)?, }) } } - impl<'a> ::planus::TableRead<'a> for FingerprintRef<'a> { + impl<'a> ::planus::TableRead<'a> for IceParametersRef<'a> { #[inline] fn from_buffer( buffer: ::planus::SliceWithStartOffset<'a>, @@ -75252,7 +76749,7 @@ mod root { } } - impl<'a> ::planus::VectorReadInner<'a> for FingerprintRef<'a> { + impl<'a> ::planus::VectorReadInner<'a> for IceParametersRef<'a> { type Error = ::planus::Error; const STRIDE: usize = 4; @@ -75262,7 +76759,7 @@ mod root { ) -> ::planus::Result { ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { error_kind.with_error_location( - "[FingerprintRef]", + "[IceParametersRef]", "get", buffer.offset_from_start, ) @@ -75270,8 +76767,8 @@ mod root { } } - impl ::planus::VectorWrite<::planus::Offset> for Fingerprint { - type Value = ::planus::Offset; + impl ::planus::VectorWrite<::planus::Offset> for IceParameters { + type Value = ::planus::Offset; const STRIDE: usize = 4; #[inline] fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { @@ -75280,7 +76777,7 @@ mod root { #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[::planus::Offset], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { @@ -75295,7 +76792,7 @@ mod root { } } - impl<'a> ::planus::ReadAsRoot<'a> for FingerprintRef<'a> { + impl<'a> ::planus::ReadAsRoot<'a> for IceParametersRef<'a> { fn read_as_root(slice: &'a [u8]) -> ::planus::Result { ::planus::TableRead::from_buffer( ::planus::SliceWithStartOffset { @@ -75305,681 +76802,700 @@ mod root { 0, ) .map_err(|error_kind| { - error_kind.with_error_location("[FingerprintRef]", "read_as_root", 0) + error_kind.with_error_location("[IceParametersRef]", "read_as_root", 0) }) } } - /// The table `DtlsParameters` in the namespace `FBS.WebRtcTransport` + /// The enum `IceCandidateType` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `DtlsParameters` in the file `../worker/fbs/webRtcTransport.fbs:29` + /// * Enum `IceCandidateType` in the file `../worker/fbs/webRtcTransport.fbs:62` #[derive( + Copy, Clone, Debug, PartialEq, - PartialOrd, Eq, + PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - pub struct DtlsParameters { - /// The field `fingerprints` in the table `DtlsParameters` - pub fingerprints: ::planus::alloc::vec::Vec, - /// The field `role` in the table `DtlsParameters` - pub role: ::core::option::Option<::planus::alloc::string::String>, + #[repr(u8)] + pub enum IceCandidateType { + /// The variant `HOST` in the enum `IceCandidateType` + Host = 0, } - impl DtlsParameters { - /// Creates a [DtlsParametersBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> DtlsParametersBuilder<()> { - DtlsParametersBuilder(()) - } + impl IceCandidateType { + /// Array containing all valid variants of IceCandidateType + pub const ENUM_VALUES: [Self; 1] = [Self::Host]; + } - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_fingerprints: impl ::planus::WriteAs< - ::planus::Offset<[::planus::Offset]>, - >, - field_role: impl ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - ) -> ::planus::Offset { - let prepared_fingerprints = field_fingerprints.prepare(builder); - let prepared_role = field_role.prepare(builder); + impl ::core::convert::TryFrom for IceCandidateType { + type Error = ::planus::errors::UnknownEnumTagKind; + #[inline] + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(IceCandidateType::Host), - let mut table_writer: ::planus::table_writer::TableWriter<8> = - ::core::default::Default::default(); - table_writer - .write_entry::<::planus::Offset<[::planus::Offset]>>(0); - if prepared_role.is_some() { - table_writer.write_entry::<::planus::Offset>(1); + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), } + } + } - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_fingerprints); - if let ::core::option::Option::Some(prepared_role) = prepared_role { - object_writer.write::<_, _, 4>(&prepared_role); - } - }); - } - builder.current_offset() + impl ::core::convert::From for u8 { + #[inline] + fn from(value: IceCandidateType) -> Self { + value as u8 } } - impl ::planus::WriteAs<::planus::Offset> for DtlsParameters { - type Prepared = ::planus::Offset; + impl ::planus::Primitive for IceCandidateType { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } + impl ::planus::WriteAsPrimitive for IceCandidateType { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl ::planus::WriteAsOptional<::planus::Offset> for DtlsParameters { - type Prepared = ::planus::Offset; + impl ::planus::WriteAs for IceCandidateType { + type Prepared = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, _builder: &mut ::planus::Builder) -> IceCandidateType { + *self } } - impl ::planus::WriteAsOffset for DtlsParameters { + impl ::planus::WriteAsDefault for IceCandidateType { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - DtlsParameters::create(builder, &self.fingerprints, &self.role) + _builder: &mut ::planus::Builder, + default: &IceCandidateType, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - /// Builder for serializing an instance of the [DtlsParameters] type. - /// - /// Can be created using the [DtlsParameters::builder] method. - #[derive(Debug)] - #[must_use] - pub struct DtlsParametersBuilder(State); + impl ::planus::WriteAsOptional for IceCandidateType { + type Prepared = Self; - impl DtlsParametersBuilder<()> { - /// Setter for the [`fingerprints` field](DtlsParameters#structfield.fingerprints). #[inline] - #[allow(clippy::type_complexity)] - pub fn fingerprints(self, value: T0) -> DtlsParametersBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - { - DtlsParametersBuilder((value,)) + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl DtlsParametersBuilder<(T0,)> { - /// Setter for the [`role` field](DtlsParameters#structfield.role). - #[inline] - #[allow(clippy::type_complexity)] - pub fn role(self, value: T1) -> DtlsParametersBuilder<(T0, T1)> - where - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - { - let (v0,) = self.0; - DtlsParametersBuilder((v0, value)) - } - - /// Sets the [`role` field](DtlsParameters#structfield.role) to null. + impl<'buf> ::planus::TableRead<'buf> for IceCandidateType { #[inline] - #[allow(clippy::type_complexity)] - pub fn role_as_null(self) -> DtlsParametersBuilder<(T0, ())> { - self.role(()) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl DtlsParametersBuilder<(T0, T1)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [DtlsParameters]. + impl<'buf> ::planus::VectorReadInner<'buf> for IceCandidateType { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { - ::planus::WriteAsOffset::prepare(&self, builder) + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "IceCandidateType", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAs<::planus::Offset> - for DtlsParametersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; + impl ::planus::VectorWrite for IceCandidateType { + const STRIDE: usize = 1; + + type Value = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self + } + + #[inline] + unsafe fn write_values( + values: &[Self], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - i as u32, + ); + } } } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOptional<::planus::Offset> - for DtlsParametersBuilder<(T0, T1)> - { - type Prepared = ::planus::Offset; + /// The enum `IceCandidateTcpType` in the namespace `FBS.WebRtcTransport` + /// + /// Generated from these locations: + /// * Enum `IceCandidateTcpType` in the file `../worker/fbs/webRtcTransport.fbs:63` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum IceCandidateTcpType { + /// The variant `PASSIVE` in the enum `IceCandidateTcpType` + Passive = 0, + } + impl IceCandidateTcpType { + /// Array containing all valid variants of IceCandidateTcpType + pub const ENUM_VALUES: [Self; 1] = [Self::Passive]; + } + + impl ::core::convert::TryFrom for IceCandidateTcpType { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(IceCandidateTcpType::Passive), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } } - impl< - T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T1: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - > ::planus::WriteAsOffset for DtlsParametersBuilder<(T0, T1)> - { + impl ::core::convert::From for u8 { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1) = &self.0; - DtlsParameters::create(builder, v0, v1) + fn from(value: IceCandidateTcpType) -> Self { + value as u8 } } - /// Reference to a deserialized [DtlsParameters]. - #[derive(Copy, Clone)] - pub struct DtlsParametersRef<'a>(::planus::table_reader::Table<'a>); + impl ::planus::Primitive for IceCandidateTcpType { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } - impl<'a> DtlsParametersRef<'a> { - /// Getter for the [`fingerprints` field](DtlsParameters#structfield.fingerprints). + impl ::planus::WriteAsPrimitive for IceCandidateTcpType { #[inline] - pub fn fingerprints( + fn write( &self, - ) -> ::planus::Result< - ::planus::Vector<'a, ::planus::Result>>, - > { - self.0.access_required(0, "DtlsParameters", "fingerprints") + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } + } + + impl ::planus::WriteAs for IceCandidateTcpType { + type Prepared = Self; - /// Getter for the [`role` field](DtlsParameters#structfield.role). #[inline] - pub fn role( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(1, "DtlsParameters", "role") + fn prepare(&self, _builder: &mut ::planus::Builder) -> IceCandidateTcpType { + *self } } - impl<'a> ::core::fmt::Debug for DtlsParametersRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("DtlsParametersRef"); - f.field("fingerprints", &self.fingerprints()); - if let ::core::option::Option::Some(field_role) = self.role().transpose() { - f.field("role", &field_role); + impl ::planus::WriteAsDefault for IceCandidateTcpType { + type Prepared = Self; + + #[inline] + fn prepare( + &self, + _builder: &mut ::planus::Builder, + default: &IceCandidateTcpType, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) } - f.finish() } } - impl<'a> ::core::convert::TryFrom> for DtlsParameters { - type Error = ::planus::Error; + impl ::planus::WriteAsOptional for IceCandidateTcpType { + type Prepared = Self; - #[allow(unreachable_code)] - fn try_from(value: DtlsParametersRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - fingerprints: value.fingerprints()?.to_vec_result()?, - role: if let ::core::option::Option::Some(role) = value.role()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(role)?) - } else { - ::core::option::Option::None - }, - }) + #[inline] + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl<'a> ::planus::TableRead<'a> for DtlsParametersRef<'a> { + impl<'buf> ::planus::TableRead<'buf> for IceCandidateTcpType { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl<'a> ::planus::VectorReadInner<'a> for DtlsParametersRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - + impl<'buf> ::planus::VectorReadInner<'buf> for IceCandidateTcpType { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; + #[inline] unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { error_kind.with_error_location( - "[DtlsParametersRef]", - "get", + "IceCandidateTcpType", + "VectorRead::from_buffer", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite<::planus::Offset> for DtlsParameters { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for IceCandidateTcpType { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for DtlsParametersRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[DtlsParametersRef]", "read_as_root", 0) - }) - } - } - - /// The table `IceParameters` in the namespace `FBS.WebRtcTransport` + /// The enum `IceRole` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `IceParameters` in the file `../worker/fbs/webRtcTransport.fbs:34` + /// * Enum `IceRole` in the file `../worker/fbs/webRtcTransport.fbs:64` #[derive( + Copy, Clone, Debug, PartialEq, - PartialOrd, Eq, + PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize, )] - pub struct IceParameters { - /// The field `username_fragment` in the table `IceParameters` - pub username_fragment: ::planus::alloc::string::String, - /// The field `password` in the table `IceParameters` - pub password: ::planus::alloc::string::String, - /// The field `ice_lite` in the table `IceParameters` - pub ice_lite: bool, - } - - impl IceParameters { - /// Creates a [IceParametersBuilder] for serializing an instance of this table. - #[inline] - pub fn builder() -> IceParametersBuilder<()> { - IceParametersBuilder(()) - } + #[repr(u8)] + pub enum IceRole { + /// The variant `CONTROLLED` in the enum `IceRole` + Controlled = 0, - #[allow(clippy::too_many_arguments)] - pub fn create( - builder: &mut ::planus::Builder, - field_username_fragment: impl ::planus::WriteAs<::planus::Offset>, - field_password: impl ::planus::WriteAs<::planus::Offset>, - field_ice_lite: impl ::planus::WriteAsDefault, - ) -> ::planus::Offset { - let prepared_username_fragment = field_username_fragment.prepare(builder); - let prepared_password = field_password.prepare(builder); - let prepared_ice_lite = field_ice_lite.prepare(builder, &true); + /// The variant `CONTROLLING` in the enum `IceRole` + Controlling = 1, + } - let mut table_writer: ::planus::table_writer::TableWriter<10> = - ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); - if prepared_ice_lite.is_some() { - table_writer.write_entry::(2); - } + impl IceRole { + /// Array containing all valid variants of IceRole + pub const ENUM_VALUES: [Self; 2] = [Self::Controlled, Self::Controlling]; + } - unsafe { - table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_username_fragment); - object_writer.write::<_, _, 4>(&prepared_password); - if let ::core::option::Option::Some(prepared_ice_lite) = - prepared_ice_lite - { - object_writer.write::<_, _, 1>(&prepared_ice_lite); - } - }); + impl ::core::convert::TryFrom for IceRole { + type Error = ::planus::errors::UnknownEnumTagKind; + #[inline] + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(IceRole::Controlled), + 1 => ::core::result::Result::Ok(IceRole::Controlling), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), } - builder.current_offset() } } - impl ::planus::WriteAs<::planus::Offset> for IceParameters { - type Prepared = ::planus::Offset; + impl ::core::convert::From for u8 { + #[inline] + fn from(value: IceRole) -> Self { + value as u8 + } + } + + impl ::planus::Primitive for IceRole { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } + impl ::planus::WriteAsPrimitive for IceRole { #[inline] - fn prepare( + fn write( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } } - impl ::planus::WriteAsOptional<::planus::Offset> for IceParameters { - type Prepared = ::planus::Offset; + impl ::planus::WriteAs for IceRole { + type Prepared = Self; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn prepare(&self, _builder: &mut ::planus::Builder) -> IceRole { + *self } } - impl ::planus::WriteAsOffset for IceParameters { + impl ::planus::WriteAsDefault for IceRole { + type Prepared = Self; + #[inline] fn prepare( &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - IceParameters::create( - builder, - &self.username_fragment, - &self.password, - self.ice_lite, - ) + _builder: &mut ::planus::Builder, + default: &IceRole, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - /// Builder for serializing an instance of the [IceParameters] type. - /// - /// Can be created using the [IceParameters::builder] method. - #[derive(Debug)] - #[must_use] - pub struct IceParametersBuilder(State); + impl ::planus::WriteAsOptional for IceRole { + type Prepared = Self; - impl IceParametersBuilder<()> { - /// Setter for the [`username_fragment` field](IceParameters#structfield.username_fragment). #[inline] - #[allow(clippy::type_complexity)] - pub fn username_fragment(self, value: T0) -> IceParametersBuilder<(T0,)> - where - T0: ::planus::WriteAs<::planus::Offset>, - { - IceParametersBuilder((value,)) + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl IceParametersBuilder<(T0,)> { - /// Setter for the [`password` field](IceParameters#structfield.password). + impl<'buf> ::planus::TableRead<'buf> for IceRole { #[inline] - #[allow(clippy::type_complexity)] - pub fn password(self, value: T1) -> IceParametersBuilder<(T0, T1)> - where - T1: ::planus::WriteAs<::planus::Offset>, - { - let (v0,) = self.0; - IceParametersBuilder((v0, value)) + fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl IceParametersBuilder<(T0, T1)> { - /// Setter for the [`ice_lite` field](IceParameters#structfield.ice_lite). + impl<'buf> ::planus::VectorReadInner<'buf> for IceRole { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; #[inline] - #[allow(clippy::type_complexity)] - pub fn ice_lite(self, value: T2) -> IceParametersBuilder<(T0, T1, T2)> - where - T2: ::planus::WriteAsDefault, + unsafe fn from_buffer( + buffer: ::planus::SliceWithStartOffset<'buf>, + offset: usize, + ) -> ::core::result::Result { - let (v0, v1) = self.0; - IceParametersBuilder((v0, v1, value)) + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { + error_kind.with_error_location( + "IceRole", + "VectorRead::from_buffer", + buffer.offset_from_start, + ) + }) } + } + + impl ::planus::VectorWrite for IceRole { + const STRIDE: usize = 1; + + type Value = Self; - /// Sets the [`ice_lite` field](IceParameters#structfield.ice_lite) to the default value. #[inline] - #[allow(clippy::type_complexity)] - pub fn ice_lite_as_default( - self, - ) -> IceParametersBuilder<(T0, T1, ::planus::DefaultValue)> { - self.ice_lite(::planus::DefaultValue) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } - } - impl IceParametersBuilder<(T0, T1, T2)> { - /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [IceParameters]. #[inline] - pub fn finish( - self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset - where - Self: ::planus::WriteAsOffset, - { - ::planus::WriteAsOffset::prepare(&self, builder) + unsafe fn write_values( + values: &[Self], + bytes: *mut ::core::mem::MaybeUninit, + buffer_position: u32, + ) { + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; + for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { + ::planus::WriteAsPrimitive::write( + v, + ::planus::Cursor::new(&mut *bytes.add(i)), + buffer_position - i as u32, + ); + } } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAs<::planus::Offset> - for IceParametersBuilder<(T0, T1, T2)> - { - type Prepared = ::planus::Offset; + /// The enum `IceState` in the namespace `FBS.WebRtcTransport` + /// + /// Generated from these locations: + /// * Enum `IceState` in the file `../worker/fbs/webRtcTransport.fbs:65` + #[derive( + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] + #[repr(u8)] + pub enum IceState { + /// The variant `NEW` in the enum `IceState` + New = 0, - #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - ::planus::WriteAsOffset::prepare(self, builder) - } + /// The variant `CONNECTED` in the enum `IceState` + Connected = 1, + + /// The variant `COMPLETED` in the enum `IceState` + Completed = 2, + + /// The variant `DISCONNECTED` in the enum `IceState` + Disconnected = 3, } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAsOptional<::planus::Offset> - for IceParametersBuilder<(T0, T1, T2)> - { - type Prepared = ::planus::Offset; + impl IceState { + /// Array containing all valid variants of IceState + pub const ENUM_VALUES: [Self; 4] = [ + Self::New, + Self::Connected, + Self::Completed, + Self::Disconnected, + ]; + } + impl ::core::convert::TryFrom for IceState { + type Error = ::planus::errors::UnknownEnumTagKind; #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::core::option::Option<::planus::Offset> { - ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder)) + fn try_from( + value: u8, + ) -> ::core::result::Result + { + #[allow(clippy::match_single_binding)] + match value { + 0 => ::core::result::Result::Ok(IceState::New), + 1 => ::core::result::Result::Ok(IceState::Connected), + 2 => ::core::result::Result::Ok(IceState::Completed), + 3 => ::core::result::Result::Ok(IceState::Disconnected), + + _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { + tag: value as i128, + }), + } } } - impl< - T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAsDefault, - > ::planus::WriteAsOffset for IceParametersBuilder<(T0, T1, T2)> - { + impl ::core::convert::From for u8 { #[inline] - fn prepare( - &self, - builder: &mut ::planus::Builder, - ) -> ::planus::Offset { - let (v0, v1, v2) = &self.0; - IceParameters::create(builder, v0, v1, v2) + fn from(value: IceState) -> Self { + value as u8 } } - /// Reference to a deserialized [IceParameters]. - #[derive(Copy, Clone)] - pub struct IceParametersRef<'a>(::planus::table_reader::Table<'a>); + impl ::planus::Primitive for IceState { + const ALIGNMENT: usize = 1; + const SIZE: usize = 1; + } - impl<'a> IceParametersRef<'a> { - /// Getter for the [`username_fragment` field](IceParameters#structfield.username_fragment). + impl ::planus::WriteAsPrimitive for IceState { #[inline] - pub fn username_fragment(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "IceParameters", "username_fragment") + fn write( + &self, + cursor: ::planus::Cursor<'_, N>, + buffer_position: u32, + ) { + (*self as u8).write(cursor, buffer_position); } + } - /// Getter for the [`password` field](IceParameters#structfield.password). - #[inline] - pub fn password(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(1, "IceParameters", "password") - } + impl ::planus::WriteAs for IceState { + type Prepared = Self; - /// Getter for the [`ice_lite` field](IceParameters#structfield.ice_lite). #[inline] - pub fn ice_lite(&self) -> ::planus::Result { - ::core::result::Result::Ok( - self.0 - .access(2, "IceParameters", "ice_lite")? - .unwrap_or(true), - ) + fn prepare(&self, _builder: &mut ::planus::Builder) -> IceState { + *self } } - impl<'a> ::core::fmt::Debug for IceParametersRef<'a> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut f = f.debug_struct("IceParametersRef"); - f.field("username_fragment", &self.username_fragment()); - f.field("password", &self.password()); - f.field("ice_lite", &self.ice_lite()); - f.finish() + impl ::planus::WriteAsDefault for IceState { + type Prepared = Self; + + #[inline] + fn prepare( + &self, + _builder: &mut ::planus::Builder, + default: &IceState, + ) -> ::core::option::Option { + if self == default { + ::core::option::Option::None + } else { + ::core::option::Option::Some(*self) + } } } - impl<'a> ::core::convert::TryFrom> for IceParameters { - type Error = ::planus::Error; + impl ::planus::WriteAsOptional for IceState { + type Prepared = Self; - #[allow(unreachable_code)] - fn try_from(value: IceParametersRef<'a>) -> ::planus::Result { - ::core::result::Result::Ok(Self { - username_fragment: ::core::convert::TryInto::try_into( - value.username_fragment()?, - )?, - password: ::core::convert::TryInto::try_into(value.password()?)?, - ice_lite: ::core::convert::TryInto::try_into(value.ice_lite()?)?, - }) + #[inline] + fn prepare( + &self, + _builder: &mut ::planus::Builder, + ) -> ::core::option::Option { + ::core::option::Option::Some(*self) } } - impl<'a> ::planus::TableRead<'a> for IceParametersRef<'a> { + impl<'buf> ::planus::TableRead<'buf> for IceState { #[inline] fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, ) -> ::core::result::Result { - ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer( - buffer, offset, - )?)) + let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; + ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) } } - impl<'a> ::planus::VectorReadInner<'a> for IceParametersRef<'a> { - type Error = ::planus::Error; - const STRIDE: usize = 4; - + impl<'buf> ::planus::VectorReadInner<'buf> for IceState { + type Error = ::planus::errors::UnknownEnumTag; + const STRIDE: usize = 1; + #[inline] unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'a>, + buffer: ::planus::SliceWithStartOffset<'buf>, offset: usize, - ) -> ::planus::Result { - ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| { + ) -> ::core::result::Result + { + let value = *buffer.buffer.get_unchecked(offset); + let value: ::core::result::Result = + ::core::convert::TryInto::try_into(value); + value.map_err(|error_kind| { error_kind.with_error_location( - "[IceParametersRef]", - "get", + "IceState", + "VectorRead::from_buffer", buffer.offset_from_start, ) }) } } - impl ::planus::VectorWrite<::planus::Offset> for IceParameters { - type Value = ::planus::Offset; - const STRIDE: usize = 4; + impl ::planus::VectorWrite for IceState { + const STRIDE: usize = 1; + + type Value = Self; + #[inline] - fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value { - ::planus::WriteAs::prepare(self, builder) + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { + *self } #[inline] unsafe fn write_values( - values: &[::planus::Offset], + values: &[Self], bytes: *mut ::core::mem::MaybeUninit, buffer_position: u32, ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 4]; + let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { ::planus::WriteAsPrimitive::write( v, ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - (Self::STRIDE * i) as u32, + buffer_position - i as u32, ); } } } - impl<'a> ::planus::ReadAsRoot<'a> for IceParametersRef<'a> { - fn read_as_root(slice: &'a [u8]) -> ::planus::Result { - ::planus::TableRead::from_buffer( - ::planus::SliceWithStartOffset { - buffer: slice, - offset_from_start: 0, - }, - 0, - ) - .map_err(|error_kind| { - error_kind.with_error_location("[IceParametersRef]", "read_as_root", 0) - }) - } - } - /// The table `IceCandidate` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `IceCandidate` in the file `../worker/fbs/webRtcTransport.fbs:40` + /// * Table `IceCandidate` in the file `../worker/fbs/webRtcTransport.fbs:72` #[derive( Clone, Debug, @@ -76003,9 +77519,9 @@ mod root { /// The field `port` in the table `IceCandidate` pub port: u16, /// The field `type` in the table `IceCandidate` - pub type_: ::core::option::Option<::planus::alloc::string::String>, + pub type_: self::IceCandidateType, /// The field `tcp_type` in the table `IceCandidate` - pub tcp_type: ::core::option::Option<::planus::alloc::string::String>, + pub tcp_type: ::core::option::Option, } impl IceCandidate { @@ -76026,12 +77542,11 @@ mod root { super::transport::Protocol, >, field_port: impl ::planus::WriteAsDefault, - field_type_: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, - >, - field_tcp_type: impl ::planus::WriteAsOptional< - ::planus::Offset<::core::primitive::str>, + field_type_: impl ::planus::WriteAsDefault< + self::IceCandidateType, + self::IceCandidateType, >, + field_tcp_type: impl ::planus::WriteAsOptional, ) -> ::planus::Offset { let prepared_foundation = field_foundation.prepare(builder); let prepared_priority = field_priority.prepare(builder, &0); @@ -76039,7 +77554,8 @@ mod root { let prepared_protocol = field_protocol.prepare(builder, &super::transport::Protocol::Udp); let prepared_port = field_port.prepare(builder, &0); - let prepared_type_ = field_type_.prepare(builder); + let prepared_type_ = + field_type_.prepare(builder, &self::IceCandidateType::Host); let prepared_tcp_type = field_tcp_type.prepare(builder); let mut table_writer: ::planus::table_writer::TableWriter<18> = @@ -76049,18 +77565,18 @@ mod root { table_writer.write_entry::(1); } table_writer.write_entry::<::planus::Offset>(2); - if prepared_type_.is_some() { - table_writer.write_entry::<::planus::Offset>(5); - } - if prepared_tcp_type.is_some() { - table_writer.write_entry::<::planus::Offset>(6); - } if prepared_port.is_some() { table_writer.write_entry::(4); } if prepared_protocol.is_some() { table_writer.write_entry::(3); } + if prepared_type_.is_some() { + table_writer.write_entry::(5); + } + if prepared_tcp_type.is_some() { + table_writer.write_entry::(6); + } unsafe { table_writer.finish(builder, |object_writer| { @@ -76071,14 +77587,6 @@ mod root { object_writer.write::<_, _, 4>(&prepared_priority); } object_writer.write::<_, _, 4>(&prepared_ip); - if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { - object_writer.write::<_, _, 4>(&prepared_type_); - } - if let ::core::option::Option::Some(prepared_tcp_type) = - prepared_tcp_type - { - object_writer.write::<_, _, 4>(&prepared_tcp_type); - } if let ::core::option::Option::Some(prepared_port) = prepared_port { object_writer.write::<_, _, 2>(&prepared_port); } @@ -76087,6 +77595,14 @@ mod root { { object_writer.write::<_, _, 1>(&prepared_protocol); } + if let ::core::option::Option::Some(prepared_type_) = prepared_type_ { + object_writer.write::<_, _, 1>(&prepared_type_); + } + if let ::core::option::Option::Some(prepared_tcp_type) = + prepared_tcp_type + { + object_writer.write::<_, _, 1>(&prepared_tcp_type); + } }); } builder.current_offset() @@ -76130,8 +77646,8 @@ mod root { &self.ip, self.protocol, self.port, - &self.type_, - &self.tcp_type, + self.type_, + self.tcp_type, ) } } @@ -76243,17 +77759,20 @@ mod root { #[allow(clippy::type_complexity)] pub fn type_(self, value: T5) -> IceCandidateBuilder<(T0, T1, T2, T3, T4, T5)> where - T5: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T5: ::planus::WriteAsDefault, { let (v0, v1, v2, v3, v4) = self.0; IceCandidateBuilder((v0, v1, v2, v3, v4, value)) } - /// Sets the [`type` field](IceCandidate#structfield.type_) to null. + /// Sets the [`type` field](IceCandidate#structfield.type_) to the default value. #[inline] #[allow(clippy::type_complexity)] - pub fn type_as_null(self) -> IceCandidateBuilder<(T0, T1, T2, T3, T4, ())> { - self.type_(()) + pub fn type_as_default( + self, + ) -> IceCandidateBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)> + { + self.type_(::planus::DefaultValue) } } @@ -76266,7 +77785,7 @@ mod root { value: T6, ) -> IceCandidateBuilder<(T0, T1, T2, T3, T4, T5, T6)> where - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T6: ::planus::WriteAsOptional, { let (v0, v1, v2, v3, v4, v5) = self.0; IceCandidateBuilder((v0, v1, v2, v3, v4, v5, value)) @@ -76303,8 +77822,8 @@ mod root { super::transport::Protocol, >, T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, > ::planus::WriteAs<::planus::Offset> for IceCandidateBuilder<(T0, T1, T2, T3, T4, T5, T6)> { @@ -76328,8 +77847,8 @@ mod root { super::transport::Protocol, >, T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, > ::planus::WriteAsOptional<::planus::Offset> for IceCandidateBuilder<(T0, T1, T2, T3, T4, T5, T6)> { @@ -76353,8 +77872,8 @@ mod root { super::transport::Protocol, >, T4: ::planus::WriteAsDefault, - T5: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, - T6: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>, + T5: ::planus::WriteAsDefault, + T6: ::planus::WriteAsOptional, > ::planus::WriteAsOffset for IceCandidateBuilder<(T0, T1, T2, T3, T4, T5, T6)> { @@ -76413,18 +77932,19 @@ mod root { /// Getter for the [`type` field](IceCandidate#structfield.type_). #[inline] - pub fn type_( - &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> - { - self.0.access(5, "IceCandidate", "type_") + pub fn type_(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(5, "IceCandidate", "type_")? + .unwrap_or(self::IceCandidateType::Host), + ) } /// Getter for the [`tcp_type` field](IceCandidate#structfield.tcp_type). #[inline] pub fn tcp_type( &self, - ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>> + ) -> ::planus::Result<::core::option::Option> { self.0.access(6, "IceCandidate", "tcp_type") } @@ -76438,9 +77958,7 @@ mod root { f.field("ip", &self.ip()); f.field("protocol", &self.protocol()); f.field("port", &self.port()); - if let ::core::option::Option::Some(field_type_) = self.type_().transpose() { - f.field("type_", &field_type_); - } + f.field("type_", &self.type_()); if let ::core::option::Option::Some(field_tcp_type) = self.tcp_type().transpose() { @@ -76461,11 +77979,7 @@ mod root { ip: ::core::convert::TryInto::try_into(value.ip()?)?, protocol: ::core::convert::TryInto::try_into(value.protocol()?)?, port: ::core::convert::TryInto::try_into(value.port()?)?, - type_: if let ::core::option::Option::Some(type_) = value.type_()? { - ::core::option::Option::Some(::core::convert::TryInto::try_into(type_)?) - } else { - ::core::option::Option::None - }, + type_: ::core::convert::TryInto::try_into(value.type_()?)?, tcp_type: if let ::core::option::Option::Some(tcp_type) = value.tcp_type()? { @@ -76552,7 +78066,7 @@ mod root { /// The table `ConnectRequest` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `ConnectRequest` in the file `../worker/fbs/webRtcTransport.fbs:50` + /// * Table `ConnectRequest` in the file `../worker/fbs/webRtcTransport.fbs:82` #[derive( Clone, Debug, @@ -76815,7 +78329,7 @@ mod root { /// The table `ConnectResponse` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `ConnectResponse` in the file `../worker/fbs/webRtcTransport.fbs:54` + /// * Table `ConnectResponse` in the file `../worker/fbs/webRtcTransport.fbs:86` #[derive( Clone, Debug, @@ -76829,7 +78343,16 @@ mod root { )] pub struct ConnectResponse { /// The field `dtls_local_role` in the table `ConnectResponse` - pub dtls_local_role: ::planus::alloc::string::String, + pub dtls_local_role: self::DtlsRole, + } + + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for ConnectResponse { + fn default() -> Self { + Self { + dtls_local_role: self::DtlsRole::Auto, + } + } } impl ConnectResponse { @@ -76842,17 +78365,24 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - field_dtls_local_role: impl ::planus::WriteAs<::planus::Offset>, + field_dtls_local_role: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_dtls_local_role = field_dtls_local_role.prepare(builder); + let prepared_dtls_local_role = + field_dtls_local_role.prepare(builder, &self::DtlsRole::Auto); let mut table_writer: ::planus::table_writer::TableWriter<6> = ::core::default::Default::default(); - table_writer.write_entry::<::planus::Offset>(0); + if prepared_dtls_local_role.is_some() { + table_writer.write_entry::(0); + } unsafe { table_writer.finish(builder, |object_writer| { - object_writer.write::<_, _, 4>(&prepared_dtls_local_role); + if let ::core::option::Option::Some(prepared_dtls_local_role) = + prepared_dtls_local_role + { + object_writer.write::<_, _, 1>(&prepared_dtls_local_role); + } }); } builder.current_offset() @@ -76889,7 +78419,7 @@ mod root { &self, builder: &mut ::planus::Builder, ) -> ::planus::Offset { - ConnectResponse::create(builder, &self.dtls_local_role) + ConnectResponse::create(builder, self.dtls_local_role) } } @@ -76906,10 +78436,19 @@ mod root { #[allow(clippy::type_complexity)] pub fn dtls_local_role(self, value: T0) -> ConnectResponseBuilder<(T0,)> where - T0: ::planus::WriteAs<::planus::Offset>, + T0: ::planus::WriteAsDefault, { ConnectResponseBuilder((value,)) } + + /// Sets the [`dtls_local_role` field](ConnectResponse#structfield.dtls_local_role) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn dtls_local_role_as_default( + self, + ) -> ConnectResponseBuilder<(::planus::DefaultValue,)> { + self.dtls_local_role(::planus::DefaultValue) + } } impl ConnectResponseBuilder<(T0,)> { @@ -76926,7 +78465,7 @@ mod root { } } - impl>> + impl> ::planus::WriteAs<::planus::Offset> for ConnectResponseBuilder<(T0,)> { @@ -76941,7 +78480,7 @@ mod root { } } - impl>> + impl> ::planus::WriteAsOptional<::planus::Offset> for ConnectResponseBuilder<(T0,)> { @@ -76956,7 +78495,7 @@ mod root { } } - impl>> + impl> ::planus::WriteAsOffset for ConnectResponseBuilder<(T0,)> { #[inline] @@ -76976,9 +78515,12 @@ mod root { impl<'a> ConnectResponseRef<'a> { /// Getter for the [`dtls_local_role` field](ConnectResponse#structfield.dtls_local_role). #[inline] - pub fn dtls_local_role(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0 - .access_required(0, "ConnectResponse", "dtls_local_role") + pub fn dtls_local_role(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(0, "ConnectResponse", "dtls_local_role")? + .unwrap_or(self::DtlsRole::Auto), + ) } } @@ -77076,7 +78618,7 @@ mod root { /// The table `DumpResponse` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `DumpResponse` in the file `../worker/fbs/webRtcTransport.fbs:58` + /// * Table `DumpResponse` in the file `../worker/fbs/webRtcTransport.fbs:90` #[derive( Clone, Debug, @@ -77092,20 +78634,20 @@ mod root { /// The field `base` in the table `DumpResponse` pub base: ::planus::alloc::boxed::Box, /// The field `ice_role` in the table `DumpResponse` - pub ice_role: ::planus::alloc::string::String, + pub ice_role: self::IceRole, /// The field `ice_parameters` in the table `DumpResponse` pub ice_parameters: ::planus::alloc::boxed::Box, /// The field `ice_candidates` in the table `DumpResponse` pub ice_candidates: ::planus::alloc::vec::Vec, /// The field `ice_state` in the table `DumpResponse` - pub ice_state: ::planus::alloc::string::String, + pub ice_state: self::IceState, /// The field `ice_selected_tuple` in the table `DumpResponse` pub ice_selected_tuple: ::core::option::Option<::planus::alloc::boxed::Box>, /// The field `dtls_parameters` in the table `DumpResponse` pub dtls_parameters: ::planus::alloc::boxed::Box, /// The field `dtls_state` in the table `DumpResponse` - pub dtls_state: ::planus::alloc::string::String, + pub dtls_state: self::DtlsState, } impl DumpResponse { @@ -77119,57 +78661,77 @@ mod root { pub fn create( builder: &mut ::planus::Builder, field_base: impl ::planus::WriteAs<::planus::Offset>, - field_ice_role: impl ::planus::WriteAs<::planus::Offset>, + field_ice_role: impl ::planus::WriteAsDefault, field_ice_parameters: impl ::planus::WriteAs<::planus::Offset>, field_ice_candidates: impl ::planus::WriteAs< ::planus::Offset<[::planus::Offset]>, >, - field_ice_state: impl ::planus::WriteAs<::planus::Offset>, + field_ice_state: impl ::planus::WriteAsDefault, field_ice_selected_tuple: impl ::planus::WriteAsOptional< ::planus::Offset, >, field_dtls_parameters: impl ::planus::WriteAs< ::planus::Offset, >, - field_dtls_state: impl ::planus::WriteAs<::planus::Offset>, + field_dtls_state: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { let prepared_base = field_base.prepare(builder); - let prepared_ice_role = field_ice_role.prepare(builder); + let prepared_ice_role = + field_ice_role.prepare(builder, &self::IceRole::Controlled); let prepared_ice_parameters = field_ice_parameters.prepare(builder); let prepared_ice_candidates = field_ice_candidates.prepare(builder); - let prepared_ice_state = field_ice_state.prepare(builder); + let prepared_ice_state = field_ice_state.prepare(builder, &self::IceState::New); let prepared_ice_selected_tuple = field_ice_selected_tuple.prepare(builder); let prepared_dtls_parameters = field_dtls_parameters.prepare(builder); - let prepared_dtls_state = field_dtls_state.prepare(builder); + let prepared_dtls_state = + field_dtls_state.prepare(builder, &self::DtlsState::New); let mut table_writer: ::planus::table_writer::TableWriter<20> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); table_writer.write_entry::<::planus::Offset>(2); table_writer .write_entry::<::planus::Offset<[::planus::Offset]>>(3); - table_writer.write_entry::<::planus::Offset>(4); if prepared_ice_selected_tuple.is_some() { table_writer.write_entry::<::planus::Offset>(5); } table_writer.write_entry::<::planus::Offset>(6); - table_writer.write_entry::<::planus::Offset>(7); + if prepared_ice_role.is_some() { + table_writer.write_entry::(1); + } + if prepared_ice_state.is_some() { + table_writer.write_entry::(4); + } + if prepared_dtls_state.is_some() { + table_writer.write_entry::(7); + } unsafe { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_ice_role); object_writer.write::<_, _, 4>(&prepared_ice_parameters); object_writer.write::<_, _, 4>(&prepared_ice_candidates); - object_writer.write::<_, _, 4>(&prepared_ice_state); if let ::core::option::Option::Some(prepared_ice_selected_tuple) = prepared_ice_selected_tuple { object_writer.write::<_, _, 4>(&prepared_ice_selected_tuple); } object_writer.write::<_, _, 4>(&prepared_dtls_parameters); - object_writer.write::<_, _, 4>(&prepared_dtls_state); + if let ::core::option::Option::Some(prepared_ice_role) = + prepared_ice_role + { + object_writer.write::<_, _, 1>(&prepared_ice_role); + } + if let ::core::option::Option::Some(prepared_ice_state) = + prepared_ice_state + { + object_writer.write::<_, _, 1>(&prepared_ice_state); + } + if let ::core::option::Option::Some(prepared_dtls_state) = + prepared_dtls_state + { + object_writer.write::<_, _, 1>(&prepared_dtls_state); + } }); } builder.current_offset() @@ -77209,13 +78771,13 @@ mod root { DumpResponse::create( builder, &self.base, - &self.ice_role, + self.ice_role, &self.ice_parameters, &self.ice_candidates, - &self.ice_state, + self.ice_state, &self.ice_selected_tuple, &self.dtls_parameters, - &self.dtls_state, + self.dtls_state, ) } } @@ -77245,11 +78807,20 @@ mod root { #[allow(clippy::type_complexity)] pub fn ice_role(self, value: T1) -> DumpResponseBuilder<(T0, T1)> where - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, { let (v0,) = self.0; DumpResponseBuilder((v0, value)) } + + /// Sets the [`ice_role` field](DumpResponse#structfield.ice_role) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_role_as_default( + self, + ) -> DumpResponseBuilder<(T0, ::planus::DefaultValue)> { + self.ice_role(::planus::DefaultValue) + } } impl DumpResponseBuilder<(T0, T1)> { @@ -77284,11 +78855,20 @@ mod root { #[allow(clippy::type_complexity)] pub fn ice_state(self, value: T4) -> DumpResponseBuilder<(T0, T1, T2, T3, T4)> where - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, { let (v0, v1, v2, v3) = self.0; DumpResponseBuilder((v0, v1, v2, v3, value)) } + + /// Sets the [`ice_state` field](DumpResponse#structfield.ice_state) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_state_as_default( + self, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> { + self.ice_state(::planus::DefaultValue) + } } impl DumpResponseBuilder<(T0, T1, T2, T3, T4)> { @@ -77341,11 +78921,21 @@ mod root { value: T7, ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> where - T7: ::planus::WriteAs<::planus::Offset>, + T7: ::planus::WriteAsDefault, { let (v0, v1, v2, v3, v4, v5, v6) = self.0; DumpResponseBuilder((v0, v1, v2, v3, v4, v5, v6, value)) } + + /// Sets the [`dtls_state` field](DumpResponse#structfield.dtls_state) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn dtls_state_as_default( + self, + ) -> DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)> + { + self.dtls_state(::planus::DefaultValue) + } } impl DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { @@ -77364,13 +78954,13 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAs<::planus::Offset>, T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, T5: ::planus::WriteAsOptional<::planus::Offset>, T6: ::planus::WriteAs<::planus::Offset>, - T7: ::planus::WriteAs<::planus::Offset>, + T7: ::planus::WriteAsDefault, > ::planus::WriteAs<::planus::Offset> for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { @@ -77387,13 +78977,13 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAs<::planus::Offset>, T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, T5: ::planus::WriteAsOptional<::planus::Offset>, T6: ::planus::WriteAs<::planus::Offset>, - T7: ::planus::WriteAs<::planus::Offset>, + T7: ::planus::WriteAsDefault, > ::planus::WriteAsOptional<::planus::Offset> for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { @@ -77410,13 +79000,13 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, T2: ::planus::WriteAs<::planus::Offset>, T3: ::planus::WriteAs<::planus::Offset<[::planus::Offset]>>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, T5: ::planus::WriteAsOptional<::planus::Offset>, T6: ::planus::WriteAs<::planus::Offset>, - T7: ::planus::WriteAs<::planus::Offset>, + T7: ::planus::WriteAsDefault, > ::planus::WriteAsOffset for DumpResponseBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> { @@ -77443,8 +79033,12 @@ mod root { /// Getter for the [`ice_role` field](DumpResponse#structfield.ice_role). #[inline] - pub fn ice_role(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(1, "DumpResponse", "ice_role") + pub fn ice_role(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "DumpResponse", "ice_role")? + .unwrap_or(self::IceRole::Controlled), + ) } /// Getter for the [`ice_parameters` field](DumpResponse#structfield.ice_parameters). @@ -77465,8 +79059,12 @@ mod root { /// Getter for the [`ice_state` field](DumpResponse#structfield.ice_state). #[inline] - pub fn ice_state(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(4, "DumpResponse", "ice_state") + pub fn ice_state(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(4, "DumpResponse", "ice_state")? + .unwrap_or(self::IceState::New), + ) } /// Getter for the [`ice_selected_tuple` field](DumpResponse#structfield.ice_selected_tuple). @@ -77486,8 +79084,12 @@ mod root { /// Getter for the [`dtls_state` field](DumpResponse#structfield.dtls_state). #[inline] - pub fn dtls_state(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(7, "DumpResponse", "dtls_state") + pub fn dtls_state(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(7, "DumpResponse", "dtls_state")? + .unwrap_or(self::DtlsState::New), + ) } } @@ -77616,7 +79218,7 @@ mod root { /// The table `GetStatsResponse` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `GetStatsResponse` in the file `../worker/fbs/webRtcTransport.fbs:69` + /// * Table `GetStatsResponse` in the file `../worker/fbs/webRtcTransport.fbs:101` #[derive( Clone, Debug, PartialEq, PartialOrd, ::serde::Serialize, ::serde::Deserialize, )] @@ -77624,14 +79226,14 @@ mod root { /// The field `base` in the table `GetStatsResponse` pub base: ::planus::alloc::boxed::Box, /// The field `ice_role` in the table `GetStatsResponse` - pub ice_role: ::planus::alloc::string::String, + pub ice_role: self::IceRole, /// The field `ice_state` in the table `GetStatsResponse` - pub ice_state: ::planus::alloc::string::String, + pub ice_state: self::IceState, /// The field `ice_selected_tuple` in the table `GetStatsResponse` pub ice_selected_tuple: ::core::option::Option<::planus::alloc::boxed::Box>, /// The field `dtls_state` in the table `GetStatsResponse` - pub dtls_state: ::planus::alloc::string::String, + pub dtls_state: self::DtlsState, } impl GetStatsResponse { @@ -77645,40 +79247,60 @@ mod root { pub fn create( builder: &mut ::planus::Builder, field_base: impl ::planus::WriteAs<::planus::Offset>, - field_ice_role: impl ::planus::WriteAs<::planus::Offset>, - field_ice_state: impl ::planus::WriteAs<::planus::Offset>, + field_ice_role: impl ::planus::WriteAsDefault, + field_ice_state: impl ::planus::WriteAsDefault, field_ice_selected_tuple: impl ::planus::WriteAsOptional< ::planus::Offset, >, - field_dtls_state: impl ::planus::WriteAs<::planus::Offset>, + field_dtls_state: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { let prepared_base = field_base.prepare(builder); - let prepared_ice_role = field_ice_role.prepare(builder); - let prepared_ice_state = field_ice_state.prepare(builder); + let prepared_ice_role = + field_ice_role.prepare(builder, &self::IceRole::Controlled); + let prepared_ice_state = field_ice_state.prepare(builder, &self::IceState::New); let prepared_ice_selected_tuple = field_ice_selected_tuple.prepare(builder); - let prepared_dtls_state = field_dtls_state.prepare(builder); + let prepared_dtls_state = + field_dtls_state.prepare(builder, &self::DtlsState::New); let mut table_writer: ::planus::table_writer::TableWriter<14> = ::core::default::Default::default(); table_writer.write_entry::<::planus::Offset>(0); - table_writer.write_entry::<::planus::Offset>(1); - table_writer.write_entry::<::planus::Offset>(2); if prepared_ice_selected_tuple.is_some() { table_writer.write_entry::<::planus::Offset>(3); } - table_writer.write_entry::<::planus::Offset>(4); + if prepared_ice_role.is_some() { + table_writer.write_entry::(1); + } + if prepared_ice_state.is_some() { + table_writer.write_entry::(2); + } + if prepared_dtls_state.is_some() { + table_writer.write_entry::(4); + } unsafe { table_writer.finish(builder, |object_writer| { object_writer.write::<_, _, 4>(&prepared_base); - object_writer.write::<_, _, 4>(&prepared_ice_role); - object_writer.write::<_, _, 4>(&prepared_ice_state); if let ::core::option::Option::Some(prepared_ice_selected_tuple) = prepared_ice_selected_tuple { object_writer.write::<_, _, 4>(&prepared_ice_selected_tuple); } - object_writer.write::<_, _, 4>(&prepared_dtls_state); + if let ::core::option::Option::Some(prepared_ice_role) = + prepared_ice_role + { + object_writer.write::<_, _, 1>(&prepared_ice_role); + } + if let ::core::option::Option::Some(prepared_ice_state) = + prepared_ice_state + { + object_writer.write::<_, _, 1>(&prepared_ice_state); + } + if let ::core::option::Option::Some(prepared_dtls_state) = + prepared_dtls_state + { + object_writer.write::<_, _, 1>(&prepared_dtls_state); + } }); } builder.current_offset() @@ -77718,10 +79340,10 @@ mod root { GetStatsResponse::create( builder, &self.base, - &self.ice_role, - &self.ice_state, + self.ice_role, + self.ice_state, &self.ice_selected_tuple, - &self.dtls_state, + self.dtls_state, ) } } @@ -77751,11 +79373,20 @@ mod root { #[allow(clippy::type_complexity)] pub fn ice_role(self, value: T1) -> GetStatsResponseBuilder<(T0, T1)> where - T1: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, { let (v0,) = self.0; GetStatsResponseBuilder((v0, value)) } + + /// Sets the [`ice_role` field](GetStatsResponse#structfield.ice_role) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_role_as_default( + self, + ) -> GetStatsResponseBuilder<(T0, ::planus::DefaultValue)> { + self.ice_role(::planus::DefaultValue) + } } impl GetStatsResponseBuilder<(T0, T1)> { @@ -77764,11 +79395,20 @@ mod root { #[allow(clippy::type_complexity)] pub fn ice_state(self, value: T2) -> GetStatsResponseBuilder<(T0, T1, T2)> where - T2: ::planus::WriteAs<::planus::Offset>, + T2: ::planus::WriteAsDefault, { let (v0, v1) = self.0; GetStatsResponseBuilder((v0, v1, value)) } + + /// Sets the [`ice_state` field](GetStatsResponse#structfield.ice_state) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn ice_state_as_default( + self, + ) -> GetStatsResponseBuilder<(T0, T1, ::planus::DefaultValue)> { + self.ice_state(::planus::DefaultValue) + } } impl GetStatsResponseBuilder<(T0, T1, T2)> { @@ -77805,11 +79445,21 @@ mod root { value: T4, ) -> GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> where - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, { let (v0, v1, v2, v3) = self.0; GetStatsResponseBuilder((v0, v1, v2, v3, value)) } + + /// Sets the [`dtls_state` field](GetStatsResponse#structfield.dtls_state) to the default value. + #[inline] + #[allow(clippy::type_complexity)] + pub fn dtls_state_as_default( + self, + ) -> GetStatsResponseBuilder<(T0, T1, T2, T3, ::planus::DefaultValue)> + { + self.dtls_state(::planus::DefaultValue) + } } impl GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { @@ -77828,10 +79478,10 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, T3: ::planus::WriteAsOptional<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, > ::planus::WriteAs<::planus::Offset> for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { @@ -77848,10 +79498,10 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, T3: ::planus::WriteAsOptional<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, > ::planus::WriteAsOptional<::planus::Offset> for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { @@ -77868,10 +79518,10 @@ mod root { impl< T0: ::planus::WriteAs<::planus::Offset>, - T1: ::planus::WriteAs<::planus::Offset>, - T2: ::planus::WriteAs<::planus::Offset>, + T1: ::planus::WriteAsDefault, + T2: ::planus::WriteAsDefault, T3: ::planus::WriteAsOptional<::planus::Offset>, - T4: ::planus::WriteAs<::planus::Offset>, + T4: ::planus::WriteAsDefault, > ::planus::WriteAsOffset for GetStatsResponseBuilder<(T0, T1, T2, T3, T4)> { @@ -77898,14 +79548,22 @@ mod root { /// Getter for the [`ice_role` field](GetStatsResponse#structfield.ice_role). #[inline] - pub fn ice_role(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(1, "GetStatsResponse", "ice_role") + pub fn ice_role(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(1, "GetStatsResponse", "ice_role")? + .unwrap_or(self::IceRole::Controlled), + ) } /// Getter for the [`ice_state` field](GetStatsResponse#structfield.ice_state). #[inline] - pub fn ice_state(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(2, "GetStatsResponse", "ice_state") + pub fn ice_state(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(2, "GetStatsResponse", "ice_state")? + .unwrap_or(self::IceState::New), + ) } /// Getter for the [`ice_selected_tuple` field](GetStatsResponse#structfield.ice_selected_tuple). @@ -77919,8 +79577,12 @@ mod root { /// Getter for the [`dtls_state` field](GetStatsResponse#structfield.dtls_state). #[inline] - pub fn dtls_state(&self) -> ::planus::Result<&'a ::core::primitive::str> { - self.0.access_required(4, "GetStatsResponse", "dtls_state") + pub fn dtls_state(&self) -> ::planus::Result { + ::core::result::Result::Ok( + self.0 + .access(4, "GetStatsResponse", "dtls_state")? + .unwrap_or(self::DtlsState::New), + ) } } @@ -78039,7 +79701,7 @@ mod root { /// The table `IceSelectedTupleChangeNotification` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `IceSelectedTupleChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:79` + /// * Table `IceSelectedTupleChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:111` #[derive( Clone, Debug, @@ -78319,386 +79981,10 @@ mod root { } } - /// The enum `IceState` in the namespace `FBS.WebRtcTransport` - /// - /// Generated from these locations: - /// * Enum `IceState` in the file `../worker/fbs/webRtcTransport.fbs:83` - #[derive( - Copy, - Clone, - Debug, - PartialEq, - Eq, - PartialOrd, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - #[repr(u8)] - pub enum IceState { - /// The variant `NEW` in the enum `IceState` - New = 0, - - /// The variant `CONNECTED` in the enum `IceState` - Connected = 1, - - /// The variant `COMPLETED` in the enum `IceState` - Completed = 2, - - /// The variant `DISCONNECTED` in the enum `IceState` - Disconnected = 3, - - /// The variant `CLOSED` in the enum `IceState` - Closed = 4, - } - - impl IceState { - /// Array containing all valid variants of IceState - pub const ENUM_VALUES: [Self; 5] = [ - Self::New, - Self::Connected, - Self::Completed, - Self::Disconnected, - Self::Closed, - ]; - } - - impl ::core::convert::TryFrom for IceState { - type Error = ::planus::errors::UnknownEnumTagKind; - #[inline] - fn try_from( - value: u8, - ) -> ::core::result::Result - { - #[allow(clippy::match_single_binding)] - match value { - 0 => ::core::result::Result::Ok(IceState::New), - 1 => ::core::result::Result::Ok(IceState::Connected), - 2 => ::core::result::Result::Ok(IceState::Completed), - 3 => ::core::result::Result::Ok(IceState::Disconnected), - 4 => ::core::result::Result::Ok(IceState::Closed), - - _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { - tag: value as i128, - }), - } - } - } - - impl ::core::convert::From for u8 { - #[inline] - fn from(value: IceState) -> Self { - value as u8 - } - } - - impl ::planus::Primitive for IceState { - const ALIGNMENT: usize = 1; - const SIZE: usize = 1; - } - - impl ::planus::WriteAsPrimitive for IceState { - #[inline] - fn write( - &self, - cursor: ::planus::Cursor<'_, N>, - buffer_position: u32, - ) { - (*self as u8).write(cursor, buffer_position); - } - } - - impl ::planus::WriteAs for IceState { - type Prepared = Self; - - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> IceState { - *self - } - } - - impl ::planus::WriteAsDefault for IceState { - type Prepared = Self; - - #[inline] - fn prepare( - &self, - _builder: &mut ::planus::Builder, - default: &IceState, - ) -> ::core::option::Option { - if self == default { - ::core::option::Option::None - } else { - ::core::option::Option::Some(*self) - } - } - } - - impl ::planus::WriteAsOptional for IceState { - type Prepared = Self; - - #[inline] - fn prepare( - &self, - _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { - ::core::option::Option::Some(*self) - } - } - - impl<'buf> ::planus::TableRead<'buf> for IceState { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result { - let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; - ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) - } - } - - impl<'buf> ::planus::VectorReadInner<'buf> for IceState { - type Error = ::planus::errors::UnknownEnumTag; - const STRIDE: usize = 1; - #[inline] - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result - { - let value = *buffer.buffer.get_unchecked(offset); - let value: ::core::result::Result = - ::core::convert::TryInto::try_into(value); - value.map_err(|error_kind| { - error_kind.with_error_location( - "IceState", - "VectorRead::from_buffer", - buffer.offset_from_start, - ) - }) - } - } - - impl ::planus::VectorWrite for IceState { - const STRIDE: usize = 1; - - type Value = Self; - - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { - *self - } - - #[inline] - unsafe fn write_values( - values: &[Self], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - i as u32, - ); - } - } - } - - /// The enum `DtlsState` in the namespace `FBS.WebRtcTransport` - /// - /// Generated from these locations: - /// * Enum `DtlsState` in the file `../worker/fbs/webRtcTransport.fbs:84` - #[derive( - Copy, - Clone, - Debug, - PartialEq, - Eq, - PartialOrd, - Ord, - Hash, - ::serde::Serialize, - ::serde::Deserialize, - )] - #[repr(u8)] - pub enum DtlsState { - /// The variant `NEW` in the enum `DtlsState` - New = 0, - - /// The variant `CONNECTING` in the enum `DtlsState` - Connecting = 1, - - /// The variant `CONNECTED` in the enum `DtlsState` - Connected = 2, - - /// The variant `FAILED` in the enum `DtlsState` - Failed = 3, - - /// The variant `CLOSED` in the enum `DtlsState` - Closed = 4, - } - - impl DtlsState { - /// Array containing all valid variants of DtlsState - pub const ENUM_VALUES: [Self; 5] = [ - Self::New, - Self::Connecting, - Self::Connected, - Self::Failed, - Self::Closed, - ]; - } - - impl ::core::convert::TryFrom for DtlsState { - type Error = ::planus::errors::UnknownEnumTagKind; - #[inline] - fn try_from( - value: u8, - ) -> ::core::result::Result - { - #[allow(clippy::match_single_binding)] - match value { - 0 => ::core::result::Result::Ok(DtlsState::New), - 1 => ::core::result::Result::Ok(DtlsState::Connecting), - 2 => ::core::result::Result::Ok(DtlsState::Connected), - 3 => ::core::result::Result::Ok(DtlsState::Failed), - 4 => ::core::result::Result::Ok(DtlsState::Closed), - - _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind { - tag: value as i128, - }), - } - } - } - - impl ::core::convert::From for u8 { - #[inline] - fn from(value: DtlsState) -> Self { - value as u8 - } - } - - impl ::planus::Primitive for DtlsState { - const ALIGNMENT: usize = 1; - const SIZE: usize = 1; - } - - impl ::planus::WriteAsPrimitive for DtlsState { - #[inline] - fn write( - &self, - cursor: ::planus::Cursor<'_, N>, - buffer_position: u32, - ) { - (*self as u8).write(cursor, buffer_position); - } - } - - impl ::planus::WriteAs for DtlsState { - type Prepared = Self; - - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> DtlsState { - *self - } - } - - impl ::planus::WriteAsDefault for DtlsState { - type Prepared = Self; - - #[inline] - fn prepare( - &self, - _builder: &mut ::planus::Builder, - default: &DtlsState, - ) -> ::core::option::Option { - if self == default { - ::core::option::Option::None - } else { - ::core::option::Option::Some(*self) - } - } - } - - impl ::planus::WriteAsOptional for DtlsState { - type Prepared = Self; - - #[inline] - fn prepare( - &self, - _builder: &mut ::planus::Builder, - ) -> ::core::option::Option { - ::core::option::Option::Some(*self) - } - } - - impl<'buf> ::planus::TableRead<'buf> for DtlsState { - #[inline] - fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result { - let n: u8 = ::planus::TableRead::from_buffer(buffer, offset)?; - ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?) - } - } - - impl<'buf> ::planus::VectorReadInner<'buf> for DtlsState { - type Error = ::planus::errors::UnknownEnumTag; - const STRIDE: usize = 1; - #[inline] - unsafe fn from_buffer( - buffer: ::planus::SliceWithStartOffset<'buf>, - offset: usize, - ) -> ::core::result::Result - { - let value = *buffer.buffer.get_unchecked(offset); - let value: ::core::result::Result = - ::core::convert::TryInto::try_into(value); - value.map_err(|error_kind| { - error_kind.with_error_location( - "DtlsState", - "VectorRead::from_buffer", - buffer.offset_from_start, - ) - }) - } - } - - impl ::planus::VectorWrite for DtlsState { - const STRIDE: usize = 1; - - type Value = Self; - - #[inline] - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { - *self - } - - #[inline] - unsafe fn write_values( - values: &[Self], - bytes: *mut ::core::mem::MaybeUninit, - buffer_position: u32, - ) { - let bytes = bytes as *mut [::core::mem::MaybeUninit; 1]; - for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) { - ::planus::WriteAsPrimitive::write( - v, - ::planus::Cursor::new(&mut *bytes.add(i)), - buffer_position - i as u32, - ); - } - } - } - /// The table `IceStateChangeNotification` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `IceStateChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:86` + /// * Table `IceStateChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:115` #[derive( Clone, Debug, @@ -78999,7 +80285,7 @@ mod root { /// The table `DtlsStateChangeNotification` in the namespace `FBS.WebRtcTransport` /// /// Generated from these locations: - /// * Table `DtlsStateChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:90` + /// * Table `DtlsStateChangeNotification` in the file `../worker/fbs/webRtcTransport.fbs:119` #[derive( Clone, Debug, diff --git a/rust/src/messages.rs b/rust/src/messages.rs index 0e9124b824..93ec73b62e 100644 --- a/rust/src/messages.rs +++ b/rust/src/messages.rs @@ -13,7 +13,7 @@ use crate::data_structures::{ use crate::direct_transport::DirectTransportOptions; use crate::fbs::{ direct_transport, message, pipe_transport, plain_transport, request, response, router, - transport, worker, + transport, web_rtc_transport, worker, }; use crate::ortc::RtpMapping; use crate::pipe_transport::PipeTransportOptions; @@ -757,8 +757,8 @@ impl RouterCreateDirectTransportData { direct_transport::DirectTransportOptions { base: Box::new(transport::Options { direct: true, - max_message_size: self.max_message_size, - initial_available_outgoing_bitrate: 0, + max_message_size: Some(self.max_message_size), + initial_available_outgoing_bitrate: None, enable_sctp: false, num_sctp_streams: None, max_sctp_message_size: 0, @@ -821,9 +821,31 @@ enum RouterCreateWebrtcTransportListen { }, } +impl RouterCreateWebrtcTransportListen { + pub(crate) fn to_fbs(&self) -> web_rtc_transport::Listen { + match self { + RouterCreateWebrtcTransportListen::Individual { listen_infos } => { + web_rtc_transport::Listen::ListenIndividual(Box::new( + web_rtc_transport::ListenIndividual { + listen_infos: listen_infos + .iter() + .map(|listen_info| listen_info.to_fbs()) + .collect(), + }, + )) + } + RouterCreateWebrtcTransportListen::Server { webrtc_server_id } => { + web_rtc_transport::Listen::ListenServer(Box::new(web_rtc_transport::ListenServer { + web_rtc_server_id: webrtc_server_id.to_string(), + })) + } + } + } +} + #[derive(Debug, Serialize)] #[serde(rename_all = "camelCase")] -pub(crate) struct RouterCreateWebrtcTransportRequest { +pub(crate) struct RouterCreateWebrtcTransportData { transport_id: TransportId, #[serde(flatten)] listen: RouterCreateWebrtcTransportListen, @@ -835,7 +857,7 @@ pub(crate) struct RouterCreateWebrtcTransportRequest { is_data_channel: bool, } -impl RouterCreateWebrtcTransportRequest { +impl RouterCreateWebrtcTransportData { pub(crate) fn from_options( transport_id: TransportId, webrtc_transport_options: &WebRtcTransportOptions, @@ -863,6 +885,22 @@ impl RouterCreateWebrtcTransportRequest { is_data_channel: true, } } + + pub(crate) fn to_fbs(&self) -> web_rtc_transport::WebRtcTransportOptions { + web_rtc_transport::WebRtcTransportOptions { + base: Box::new(transport::Options { + direct: false, + max_message_size: None, + initial_available_outgoing_bitrate: Some(self.initial_available_outgoing_bitrate), + enable_sctp: self.enable_sctp, + num_sctp_streams: Some(Box::new(self.num_sctp_streams.to_fbs())), + max_sctp_message_size: self.max_sctp_message_size, + sctp_send_buffer_size: self.sctp_send_buffer_size, + is_data_channel: true, + }), + listen: self.listen.to_fbs(), + } + } } #[derive(Debug, Deserialize)] @@ -880,17 +918,71 @@ pub(crate) struct WebRtcTransportData { pub(crate) sctp_state: Mutex>, } -impl Request for RouterCreateWebrtcTransportRequest { +#[derive(Debug)] +pub(crate) struct RouterCreateWebRtcTransportRequest { + pub(crate) data: RouterCreateWebrtcTransportData, +} + +impl RequestFbs for RouterCreateWebRtcTransportRequest { + const METHOD: request::Method = request::Method::RouterCreateWebrtctransport; type HandlerId = RouterId; type Response = WebRtcTransportData; - fn as_method(&self) -> &'static str { - match &self.listen { - RouterCreateWebrtcTransportListen::Individual { .. } => "router.createWebRtcTransport", - RouterCreateWebrtcTransportListen::Server { .. } => { - "router.createWebRtcTransportWithServer" - } - } + fn into_bytes(self, id: u32, handler_id: Self::HandlerId) -> Vec { + let mut builder = Builder::new(); + let data = router::CreateWebRtcTransportRequest::create( + &mut builder, + self.data.transport_id.to_string(), + self.data.to_fbs(), + ); + let request_body = + request::Body::create_create_web_rtc_transport_request(&mut builder, data); + let request = request::Request::create( + &mut builder, + id, + Self::METHOD, + handler_id.to_string(), + Some(request_body), + ); + let message_body = message::Body::create_request(&mut builder, request); + let message = message::Message::create(&mut builder, message::Type::Request, message_body); + + builder.finish(message, None).to_vec() + } + + fn convert_response( + response: Option, + ) -> Result> { + let Some(response::Body::FbsWebRtcTransportDumpResponse(data)) = response else { + panic!("Wrong message from worker: {response:?}"); + }; + + Ok(WebRtcTransportData { + ice_role: IceRole::from_fbs(data.ice_role), + ice_parameters: IceParameters::from_fbs(*data.ice_parameters), + ice_candidates: data + .ice_candidates + .iter() + .map(IceCandidate::from_fbs) + .collect(), + ice_state: Mutex::new(IceState::from_fbs(data.ice_state)), + ice_selected_tuple: Mutex::new( + data.ice_selected_tuple + .map(|tuple| TransportTuple::from_fbs(tuple.as_ref())), + ), + dtls_parameters: Mutex::new(DtlsParameters::from_fbs(*data.dtls_parameters)), + dtls_state: Mutex::new(DtlsState::from_fbs(data.dtls_state)), + dtls_remote_cert: Mutex::new(None), + sctp_parameters: data + .base + .sctp_parameters + .map(|parameters| SctpParameters::from_fbs(parameters.as_ref())), + sctp_state: Mutex::new( + data.base + .sctp_state + .map(|state| SctpState::from_fbs(&state)), + ), + }) } } @@ -936,13 +1028,13 @@ impl RouterCreatePlainTransportData { plain_transport::PlainTransportOptions { base: Box::new(transport::Options { direct: false, - initial_available_outgoing_bitrate: 0, + max_message_size: None, + initial_available_outgoing_bitrate: None, enable_sctp: self.enable_sctp, num_sctp_streams: Some(Box::new(self.num_sctp_streams.to_fbs())), max_sctp_message_size: self.max_sctp_message_size, sctp_send_buffer_size: self.sctp_send_buffer_size, is_data_channel: self.is_data_channel, - max_message_size: self.max_sctp_message_size, }), listen_info: Box::new(self.listen_info.to_fbs()), rtcp_listen_info: self @@ -951,7 +1043,7 @@ impl RouterCreatePlainTransportData { rtcp_mux: self.rtcp_mux, comedia: self.comedia, enable_srtp: self.enable_srtp, - srtp_crypto_suite: Some(self.srtp_crypto_suite.to_string()), + srtp_crypto_suite: Some(SrtpCryptoSuite::to_fbs(self.srtp_crypto_suite)), } } } @@ -1268,16 +1360,52 @@ impl RequestFbs for TransportCloseRequestFbs { } } -request_response!( - TransportId, - "transport.connect", - TransportConnectWebRtcRequest { - dtls_parameters: DtlsParameters, - }, - TransportConnectResponseWebRtc { - dtls_local_role: DtlsRole, - }, -); +#[derive(Debug)] +pub(crate) struct WebRtcTransportConnectResponse { + pub(crate) dtls_local_role: DtlsRole, +} + +#[derive(Debug)] +pub(crate) struct WebRtcTransportConnectRequest { + pub(crate) dtls_parameters: DtlsParameters, +} + +impl RequestFbs for WebRtcTransportConnectRequest { + const METHOD: request::Method = request::Method::WebrtctransportConnect; + type HandlerId = TransportId; + type Response = WebRtcTransportConnectResponse; + + fn into_bytes(self, id: u32, handler_id: Self::HandlerId) -> Vec { + let mut builder = Builder::new(); + let data = + web_rtc_transport::ConnectRequest::create(&mut builder, self.dtls_parameters.to_fbs()); + let request_body = + request::Body::create_web_rtc_transport_connect_request(&mut builder, data); + let request = request::Request::create( + &mut builder, + id, + Self::METHOD, + handler_id.to_string(), + Some(request_body), + ); + let message_body = message::Body::create_request(&mut builder, request); + let message = message::Message::create(&mut builder, message::Type::Request, message_body); + + builder.finish(message, None).to_vec() + } + + fn convert_response( + response: Option, + ) -> Result> { + let Some(response::Body::FbsWebRtcTransportConnectResponse(data)) = response else { + panic!("Wrong message from worker: {response:?}"); + }; + + Ok(WebRtcTransportConnectResponse { + dtls_local_role: DtlsRole::from_fbs(data.dtls_local_role), + }) + } +} #[derive(Debug)] pub(crate) struct PipeTransportConnectResponse { @@ -1321,7 +1449,7 @@ impl RequestFbs for PipeTransportConnectRequest { fn convert_response( response: Option, ) -> Result> { - let Some(response::Body::FbsPlainTransportConnectResponse(data)) = response else { + let Some(response::Body::FbsPipeTransportConnectResponse(data)) = response else { panic!("Wrong message from worker: {response:?}"); }; @@ -1412,15 +1540,43 @@ request_response!( TransportSetMinOutgoingBitrateRequest { bitrate: u32 }, ); -request_response!( - TransportId, - "transport.restartIce", - TransportRestartIceRequest {}, - TransportRestartIceResponse { - ice_parameters: IceParameters, - }, -); +#[derive(Debug)] +pub(crate) struct TransportRestartIceRequest {} + +impl RequestFbs for TransportRestartIceRequest { + const METHOD: request::Method = request::Method::TransportRestartIce; + type HandlerId = TransportId; + type Response = IceParameters; + + fn into_bytes(self, id: u32, handler_id: Self::HandlerId) -> Vec { + let mut builder = Builder::new(); + let request = request::Request::create( + &mut builder, + id, + Self::METHOD, + handler_id.to_string(), + None::, + ); + let message_body = message::Body::create_request(&mut builder, request); + let message = message::Message::create(&mut builder, message::Type::Request, message_body); + + builder.finish(message, None).to_vec() + } + fn convert_response( + response: Option, + ) -> Result> { + let Some(response::Body::FbsTransportRestartIceResponse(data)) = response else { + panic!("Wrong message from worker: {response:?}"); + }; + + Ok(IceParameters::from_fbs(web_rtc_transport::IceParameters { + username_fragment: data.username_fragment, + password: data.password, + ice_lite: data.ice_lite, + })) + } +} request_response!( TransportId, "transport.produce", diff --git a/rust/src/router.rs b/rust/src/router.rs index a5e2b632c1..c4ce4abc37 100644 --- a/rust/src/router.rs +++ b/rust/src/router.rs @@ -36,7 +36,8 @@ use crate::messages::{ RouterCreateAudioLevelObserverRequest, RouterCreateDirectTransportData, RouterCreateDirectTransportRequest, RouterCreatePipeTransportData, RouterCreatePipeTransportRequest, RouterCreatePlainTransportData, - RouterCreatePlainTransportRequest, RouterCreateWebrtcTransportRequest, RouterDumpRequest, + RouterCreatePlainTransportRequest, RouterCreateWebRtcTransportRequest, + RouterCreateWebrtcTransportData, RouterDumpRequest, }; use crate::pipe_transport::{ PipeTransport, PipeTransportOptions, PipeTransportRemoteParameters, WeakPipeTransport, @@ -628,12 +629,14 @@ impl Router { let data = self .inner .channel - .request( + .request_fbs( self.inner.id, - RouterCreateWebrtcTransportRequest::from_options( - transport_id, - &webrtc_transport_options, - ), + RouterCreateWebRtcTransportRequest { + data: RouterCreateWebrtcTransportData::from_options( + transport_id, + &webrtc_transport_options, + ), + }, ) .await?; diff --git a/rust/src/router/direct_transport.rs b/rust/src/router/direct_transport.rs index 6530268986..543587ad06 100644 --- a/rust/src/router/direct_transport.rs +++ b/rust/src/router/direct_transport.rs @@ -168,9 +168,9 @@ pub struct DirectTransportStat { pub available_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub available_incoming_bitrate: Option, - pub max_incoming_bitrate: u32, - pub max_outgoing_bitrate: u32, - pub min_outgoing_bitrate: u32, + pub max_incoming_bitrate: Option, + pub max_outgoing_bitrate: Option, + pub min_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub rtp_packet_loss_received: Option, #[serde(skip_serializing_if = "Option::is_none")] diff --git a/rust/src/router/pipe_transport.rs b/rust/src/router/pipe_transport.rs index 7e37e767b2..0cc91acb5a 100644 --- a/rust/src/router/pipe_transport.rs +++ b/rust/src/router/pipe_transport.rs @@ -209,9 +209,9 @@ pub struct PipeTransportStat { pub available_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub available_incoming_bitrate: Option, - pub max_incoming_bitrate: u32, - pub max_outgoing_bitrate: u32, - pub min_outgoing_bitrate: u32, + pub max_incoming_bitrate: Option, + pub max_outgoing_bitrate: Option, + pub min_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub rtp_packet_loss_received: Option, #[serde(skip_serializing_if = "Option::is_none")] diff --git a/rust/src/router/plain_transport.rs b/rust/src/router/plain_transport.rs index 933f12d2da..06e01fd096 100644 --- a/rust/src/router/plain_transport.rs +++ b/rust/src/router/plain_transport.rs @@ -234,9 +234,9 @@ pub struct PlainTransportStat { pub available_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub available_incoming_bitrate: Option, - pub max_incoming_bitrate: u32, - pub max_outgoing_bitrate: u32, - pub min_outgoing_bitrate: u32, + pub max_incoming_bitrate: Option, + pub max_outgoing_bitrate: Option, + pub min_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub rtp_packet_loss_received: Option, #[serde(skip_serializing_if = "Option::is_none")] diff --git a/rust/src/router/webrtc_transport.rs b/rust/src/router/webrtc_transport.rs index 954b24ef81..fb0079869e 100644 --- a/rust/src/router/webrtc_transport.rs +++ b/rust/src/router/webrtc_transport.rs @@ -8,8 +8,9 @@ use crate::data_structures::{ AppData, DtlsParameters, DtlsState, IceCandidate, IceParameters, IceRole, IceState, ListenInfo, SctpState, TransportTuple, }; +use crate::fbs::{response, web_rtc_transport}; use crate::messages::{ - TransportCloseRequest, TransportConnectWebRtcRequest, TransportRestartIceRequest, + TransportCloseRequestFbs, TransportRestartIceRequest, WebRtcTransportConnectRequest, WebRtcTransportData, }; use crate::producer::{Producer, ProducerId, ProducerOptions}; @@ -31,6 +32,7 @@ use nohash_hasher::IntMap; use parking_lot::Mutex; use serde::{Deserialize, Serialize}; use std::convert::TryFrom; +use std::error::Error; use std::fmt; use std::ops::Deref; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; @@ -175,7 +177,7 @@ pub struct WebRtcTransportDump { pub data_consumer_ids: Vec, pub recv_rtp_header_extensions: RecvRtpHeaderExtensions, pub rtp_listener: RtpListener, - pub max_message_size: usize, + pub max_message_size: u32, pub sctp_parameters: Option, pub sctp_state: Option, pub sctp_listener: Option, @@ -190,6 +192,89 @@ pub struct WebRtcTransportDump { pub ice_selected_tuple: Option, } +impl WebRtcTransportDump { + pub(crate) fn from_fbs(dump: web_rtc_transport::DumpResponse) -> Result> { + Ok(Self { + // Common to all Transports. + id: dump.base.id.parse()?, + direct: false, + producer_ids: dump + .base + .producer_ids + .iter() + .map(|producer_id| Ok(producer_id.parse()?)) + .collect::>>()?, + consumer_ids: dump + .base + .consumer_ids + .iter() + .map(|consumer_id| Ok(consumer_id.parse()?)) + .collect::>>()?, + map_ssrc_consumer_id: dump + .base + .map_ssrc_consumer_id + .iter() + .map(|key_value| Ok((key_value.key, key_value.value.parse()?))) + .collect::>>()?, + map_rtx_ssrc_consumer_id: dump + .base + .map_rtx_ssrc_consumer_id + .iter() + .map(|key_value| Ok((key_value.key, key_value.value.parse()?))) + .collect::>>()?, + data_producer_ids: dump + .base + .data_producer_ids + .iter() + .map(|data_producer_id| Ok(data_producer_id.parse()?)) + .collect::>>()?, + data_consumer_ids: dump + .base + .data_consumer_ids + .iter() + .map(|data_consumer_id| Ok(data_consumer_id.parse()?)) + .collect::>>()?, + recv_rtp_header_extensions: RecvRtpHeaderExtensions::from_fbs( + dump.base.recv_rtp_header_extensions.as_ref(), + ), + rtp_listener: RtpListener::from_fbs(dump.base.rtp_listener.as_ref())?, + max_message_size: dump.base.max_message_size, + sctp_parameters: dump + .base + .sctp_parameters + .as_ref() + .map(|parameters| SctpParameters::from_fbs(parameters.as_ref())), + sctp_state: dump + .base + .sctp_state + .map(|state| SctpState::from_fbs(&state)), + sctp_listener: dump.base.sctp_listener.as_ref().map(|listener| { + SctpListener::from_fbs(listener.as_ref()).expect("Error parsing SctpListner") + }), + trace_event_types: dump + .base + .trace_event_types + .iter() + .map(|event| event.to_string()) + .collect(), + // WebRtcTransport specific. + dtls_parameters: DtlsParameters::from_fbs(*dump.dtls_parameters), + dtls_state: DtlsState::from_fbs(dump.dtls_state), + ice_candidates: dump + .ice_candidates + .iter() + .map(IceCandidate::from_fbs) + .collect(), + ice_parameters: IceParameters::from_fbs(*dump.ice_parameters), + ice_role: IceRole::from_fbs(dump.ice_role), + ice_state: IceState::from_fbs(dump.ice_state), + ice_selected_tuple: dump + .ice_selected_tuple + .map(|tuple| TransportTuple::from_fbs(tuple.as_ref())), + }) + } +} + /// RTC statistics of the [`WebRtcTransport`]. #[derive(Debug, Clone, PartialOrd, PartialEq, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] @@ -201,26 +286,27 @@ pub struct WebRtcTransportStat { pub transport_id: TransportId, pub timestamp: u64, pub sctp_state: Option, - pub bytes_received: usize, + pub bytes_received: u64, pub recv_bitrate: u32, - pub bytes_sent: usize, + pub bytes_sent: u64, pub send_bitrate: u32, - pub rtp_bytes_received: usize, + pub rtp_bytes_received: u64, pub rtp_recv_bitrate: u32, - pub rtp_bytes_sent: usize, + pub rtp_bytes_sent: u64, pub rtp_send_bitrate: u32, - pub rtx_bytes_received: usize, + pub rtx_bytes_received: u64, pub rtx_recv_bitrate: u32, - pub rtx_bytes_sent: usize, + pub rtx_bytes_sent: u64, pub rtx_send_bitrate: u32, - pub probation_bytes_sent: usize, + pub probation_bytes_sent: u64, pub probation_send_bitrate: u32, #[serde(skip_serializing_if = "Option::is_none")] pub available_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub available_incoming_bitrate: Option, - #[serde(skip_serializing_if = "Option::is_none")] pub max_incoming_bitrate: Option, + pub max_outgoing_bitrate: Option, + pub min_outgoing_bitrate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub rtp_packet_loss_received: Option, #[serde(skip_serializing_if = "Option::is_none")] @@ -233,6 +319,45 @@ pub struct WebRtcTransportStat { pub dtls_state: DtlsState, } +impl WebRtcTransportStat { + pub(crate) fn from_fbs( + stats: web_rtc_transport::GetStatsResponse, + ) -> Result> { + Ok(Self { + transport_id: stats.base.transport_id.parse()?, + timestamp: stats.base.timestamp, + sctp_state: stats.base.sctp_state.as_ref().map(SctpState::from_fbs), + bytes_received: stats.base.bytes_received, + recv_bitrate: stats.base.recv_bitrate, + bytes_sent: stats.base.bytes_sent, + send_bitrate: stats.base.send_bitrate, + rtp_bytes_received: stats.base.rtp_bytes_received, + rtp_recv_bitrate: stats.base.rtp_recv_bitrate, + rtp_bytes_sent: stats.base.rtp_bytes_sent, + rtp_send_bitrate: stats.base.rtp_send_bitrate, + rtx_bytes_received: stats.base.rtx_bytes_received, + rtx_recv_bitrate: stats.base.rtx_recv_bitrate, + rtx_bytes_sent: stats.base.rtx_bytes_sent, + rtx_send_bitrate: stats.base.rtx_send_bitrate, + probation_bytes_sent: stats.base.probation_bytes_sent, + probation_send_bitrate: stats.base.probation_send_bitrate, + available_outgoing_bitrate: stats.base.available_outgoing_bitrate, + available_incoming_bitrate: stats.base.available_incoming_bitrate, + max_incoming_bitrate: stats.base.max_incoming_bitrate, + max_outgoing_bitrate: stats.base.max_outgoing_bitrate, + min_outgoing_bitrate: stats.base.min_outgoing_bitrate, + rtp_packet_loss_received: stats.base.rtp_packet_loss_received, + rtp_packet_loss_sent: stats.base.rtp_packet_loss_sent, + // WebRtcTransport specific. + ice_role: IceRole::from_fbs(stats.ice_role), + ice_state: IceState::from_fbs(stats.ice_state), + ice_selected_tuple: stats + .ice_selected_tuple + .map(|tuple| TransportTuple::from_fbs(tuple.as_ref())), + dtls_state: DtlsState::from_fbs(stats.dtls_state), + }) + } +} /// Remote parameters for [`WebRtcTransport`]. #[derive(Debug, Clone, PartialOrd, Eq, PartialEq, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] @@ -320,13 +445,13 @@ impl Inner { if close_request { let channel = self.channel.clone(); let router_id = self.router.id(); - let request = TransportCloseRequest { + let request = TransportCloseRequestFbs { transport_id: self.id, }; self.executor .spawn(async move { - if let Err(error) = channel.request(router_id, request).await { + if let Err(error) = channel.request_fbs(router_id, request).await { error!("transport closing failed on drop: {}", error); } }) @@ -517,29 +642,25 @@ impl TransportGeneric for WebRtcTransport { async fn dump(&self) -> Result { debug!("dump()"); - todo!(); - - /* - serde_json::from_value(self.dump_impl().await?).map_err(|error| { - RequestError::FailedToParse { - error: error.to_string(), - } - }) - */ + if let response::Body::FbsWebRtcTransportDumpResponse(data) = self.dump_impl().await? { + Ok(WebRtcTransportDump::from_fbs(*data).expect("Error parsing dump response")) + } else { + panic!("Wrong message from worker"); + } } async fn get_stats(&self) -> Result, RequestError> { debug!("get_stats()"); - todo!(); - - /* - serde_json::from_value(self.get_stats_impl().await?).map_err(|error| { - RequestError::FailedToParse { - error: error.to_string(), - } - }) - */ + if let response::Body::FbsWebRtcTransportGetStatsResponse(data) = + self.get_stats_impl().await? + { + Ok(vec![ + WebRtcTransportStat::from_fbs(*data).expect("Error parsing dump response") + ]) + } else { + panic!("Wrong message from worker"); + } } } @@ -737,9 +858,9 @@ impl WebRtcTransport { let response = self .inner .channel - .request( + .request_fbs( self.id(), - TransportConnectWebRtcRequest { + WebRtcTransportConnectRequest { dtls_parameters: remote_parameters.dtls_parameters, }, ) @@ -849,13 +970,10 @@ impl WebRtcTransport { pub async fn restart_ice(&self) -> Result { debug!("restart_ice()"); - let response = self - .inner + self.inner .channel - .request(self.id(), TransportRestartIceRequest {}) - .await?; - - Ok(response.ice_parameters) + .request_fbs(self.id(), TransportRestartIceRequest {}) + .await } /// Callback is called when the WebRTC server used during creation of this transport is closed diff --git a/rust/src/srtp_parameters.rs b/rust/src/srtp_parameters.rs index 464b9e2779..e7e90e500b 100644 --- a/rust/src/srtp_parameters.rs +++ b/rust/src/srtp_parameters.rs @@ -1,9 +1,8 @@ //! Collection of SRTP-related data structures that are used to specify SRTP encryption/decryption //! parameters. -use crate::fbs::transport; +use crate::fbs::srtp_parameters; use serde::{Deserialize, Serialize}; -use std::str::FromStr; /// SRTP parameters. #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Deserialize, Serialize)] @@ -16,16 +15,16 @@ pub struct SrtpParameters { } impl SrtpParameters { - pub(crate) fn from_fbs(tuple: &transport::SrtpParameters) -> Self { + pub(crate) fn from_fbs(tuple: &srtp_parameters::SrtpParameters) -> Self { Self { - crypto_suite: tuple.crypto_suite.parse().unwrap(), + crypto_suite: SrtpCryptoSuite::from_fbs(tuple.crypto_suite), key_base64: String::from(tuple.key_base64.as_str()), } } - pub(crate) fn to_fbs(&self) -> transport::SrtpParameters { - transport::SrtpParameters { - crypto_suite: self.crypto_suite.to_string(), + pub(crate) fn to_fbs(&self) -> srtp_parameters::SrtpParameters { + srtp_parameters::SrtpParameters { + crypto_suite: SrtpCryptoSuite::to_fbs(self.crypto_suite), key_base64: String::from(self.key_base64.as_str()), } } @@ -48,39 +47,28 @@ pub enum SrtpCryptoSuite { AesCm128HmacSha132, } -impl Default for SrtpCryptoSuite { - fn default() -> Self { - Self::AesCm128HmacSha180 +impl SrtpCryptoSuite { + pub(crate) fn from_fbs(crypto_suite: srtp_parameters::SrtpCryptoSuite) -> Self { + match crypto_suite { + srtp_parameters::SrtpCryptoSuite::AeadAes256Gcm => Self::AeadAes256Gcm, + srtp_parameters::SrtpCryptoSuite::AeadAes128Gcm => Self::AeadAes128Gcm, + srtp_parameters::SrtpCryptoSuite::AesCm128HmacSha180 => Self::AesCm128HmacSha180, + srtp_parameters::SrtpCryptoSuite::AesCm128HmacSha132 => Self::AesCm128HmacSha132, + } } -} -// TODO: Remove once SrtpCryptoSuite is defined in fbs. -impl ToString for SrtpCryptoSuite { - fn to_string(&self) -> String { + pub(crate) fn to_fbs(self) -> srtp_parameters::SrtpCryptoSuite { match self { - Self::AeadAes256Gcm => String::from("AEAD_AES_256_GCM"), - Self::AeadAes128Gcm => String::from("AEAD_AES_128_GCM"), - Self::AesCm128HmacSha180 => String::from("AES_CM_128_HMAC_SHA1_80"), - Self::AesCm128HmacSha132 => String::from("AES_CM_128_HMAC_SHA1_32"), + Self::AeadAes256Gcm => srtp_parameters::SrtpCryptoSuite::AeadAes256Gcm, + Self::AeadAes128Gcm => srtp_parameters::SrtpCryptoSuite::AeadAes128Gcm, + Self::AesCm128HmacSha180 => srtp_parameters::SrtpCryptoSuite::AesCm128HmacSha180, + Self::AesCm128HmacSha132 => srtp_parameters::SrtpCryptoSuite::AesCm128HmacSha132, } } } -/// Error that caused [`SrtpCryptoSuite`] parsing error. -#[derive(Debug, Eq, PartialEq)] -pub struct ParseCryptoSuiteError; - -// TODO: Remove once SrtpCryptoSuite is defined in fbs. -impl FromStr for SrtpCryptoSuite { - type Err = ParseCryptoSuiteError; - - fn from_str(s: &str) -> Result { - match s { - "AEAD_AES_256_GCM" => Ok(Self::AeadAes256Gcm), - "AEAD_AES_128_GCM" => Ok(Self::AeadAes128Gcm), - "AES_CM_128_HMAC_SHA1_80" => Ok(Self::AesCm128HmacSha180), - "AES_CM_128_HMAC_SHA1_32" => Ok(Self::AesCm128HmacSha132), - _ => Err(ParseCryptoSuiteError), - } +impl Default for SrtpCryptoSuite { + fn default() -> Self { + Self::AesCm128HmacSha180 } } diff --git a/rust/tests/integration/webrtc_transport.rs b/rust/tests/integration/webrtc_transport.rs index 21c562bf2f..7311aa364c 100644 --- a/rust/tests/integration/webrtc_transport.rs +++ b/rust/tests/integration/webrtc_transport.rs @@ -1,8 +1,8 @@ use futures_lite::future; use hash_hasher::HashedSet; use mediasoup::data_structures::{ - AppData, DtlsFingerprint, DtlsParameters, DtlsRole, DtlsState, IceCandidateTcpType, - IceCandidateType, IceRole, IceState, ListenInfo, Protocol, SctpState, + AppData, DtlsFingerprint, DtlsParameters, DtlsRole, DtlsState, IceCandidateType, IceRole, + IceState, ListenInfo, Protocol, SctpState, }; use mediasoup::prelude::*; use mediasoup::router::{Router, RouterOptions}; @@ -88,7 +88,6 @@ async fn init() -> (Worker, Router) { } #[test] -#[ignore] fn create_succeeds() { future::block_on(async move { let (_worker, router) = init().await; @@ -161,6 +160,8 @@ fn create_succeeds() { .try_into() .unwrap(), ); + // TODO: I wonder how this was not needed before... + webrtc_transport_options.enable_sctp = true; webrtc_transport_options.num_sctp_streams = NumSctpStreams { os: 2048, mis: 2048, @@ -195,42 +196,25 @@ fn create_succeeds() { ); { let ice_candidates = transport1.ice_candidates(); - assert_eq!(ice_candidates.len(), 6); + assert_eq!(ice_candidates.len(), 3); assert_eq!(ice_candidates[0].ip, "9.9.9.1".parse::().unwrap()); assert_eq!(ice_candidates[0].protocol, Protocol::Udp); assert_eq!(ice_candidates[0].r#type, IceCandidateType::Host); assert_eq!(ice_candidates[0].tcp_type, None); - assert_eq!(ice_candidates[1].ip, "9.9.9.1".parse::().unwrap()); - assert_eq!(ice_candidates[1].protocol, Protocol::Tcp); + assert_eq!(ice_candidates[1].ip, "9.9.9.2".parse::().unwrap()); + assert_eq!(ice_candidates[1].protocol, Protocol::Udp); assert_eq!(ice_candidates[1].r#type, IceCandidateType::Host); - assert_eq!( - ice_candidates[1].tcp_type, - Some(IceCandidateTcpType::Passive), - ); - assert_eq!(ice_candidates[2].ip, "9.9.9.2".parse::().unwrap()); + assert_eq!(ice_candidates[1].tcp_type, None); + assert_eq!(ice_candidates[2].ip, "127.0.0.1".parse::().unwrap()); + assert_eq!(ice_candidates[2].protocol, Protocol::Udp); + assert_eq!(ice_candidates[2].r#type, IceCandidateType::Host); + assert_eq!(ice_candidates[2].tcp_type, None); + assert_eq!(ice_candidates[2].ip, "127.0.0.1".parse::().unwrap()); assert_eq!(ice_candidates[2].protocol, Protocol::Udp); assert_eq!(ice_candidates[2].r#type, IceCandidateType::Host); assert_eq!(ice_candidates[2].tcp_type, None); - assert_eq!(ice_candidates[3].ip, "9.9.9.2".parse::().unwrap()); - assert_eq!(ice_candidates[3].protocol, Protocol::Tcp); - assert_eq!(ice_candidates[3].r#type, IceCandidateType::Host); - assert_eq!( - ice_candidates[3].tcp_type, - Some(IceCandidateTcpType::Passive), - ); - assert_eq!(ice_candidates[4].ip, "127.0.0.1".parse::().unwrap()); - assert_eq!(ice_candidates[4].protocol, Protocol::Udp); - assert_eq!(ice_candidates[4].r#type, IceCandidateType::Host); - assert_eq!(ice_candidates[4].tcp_type, None); - assert_eq!(ice_candidates[4].ip, "127.0.0.1".parse::().unwrap()); - assert_eq!(ice_candidates[4].protocol, Protocol::Udp); - assert_eq!(ice_candidates[4].r#type, IceCandidateType::Host); - assert_eq!(ice_candidates[4].tcp_type, None); assert!(ice_candidates[0].priority > ice_candidates[1].priority); assert!(ice_candidates[1].priority > ice_candidates[2].priority); - assert!(ice_candidates[2].priority > ice_candidates[3].priority); - assert!(ice_candidates[3].priority > ice_candidates[4].priority); - assert!(ice_candidates[4].priority > ice_candidates[5].priority); } assert_eq!(transport1.ice_state(), IceState::New); @@ -267,7 +251,6 @@ fn create_succeeds() { } #[test] -#[ignore] fn create_with_fixed_port_succeeds() { future::block_on(async move { let (_worker, router) = init().await; @@ -293,7 +276,6 @@ fn create_with_fixed_port_succeeds() { } #[test] -#[ignore] fn weak() { future::block_on(async move { let (_worker, router) = init().await; @@ -323,7 +305,6 @@ fn weak() { } #[test] -#[ignore] fn create_non_bindable_ip() { future::block_on(async move { let (_worker, router) = init().await; @@ -347,7 +328,6 @@ fn create_non_bindable_ip() { } #[test] -#[ignore] fn get_stats_succeeds() { future::block_on(async move { let (_worker, router) = init().await; @@ -399,7 +379,6 @@ fn get_stats_succeeds() { } #[test] -#[ignore] fn connect_succeeds() { future::block_on(async move { let (_worker, router) = init().await; @@ -624,7 +603,6 @@ fn set_min_outgoing_bitrate_fails_if_value_is_higher_than_current_max_limit() { } #[test] -#[ignore] fn restart_ice_succeeds() { future::block_on(async move { let (_worker, router) = init().await; @@ -727,7 +705,6 @@ fn enable_trace_event_succeeds() { } #[test] -#[ignore] fn close_event() { future::block_on(async move { let (_worker, router) = init().await; diff --git a/worker/fbs/pipeTransport.fbs b/worker/fbs/pipeTransport.fbs index 82cc56515e..13c548d008 100644 --- a/worker/fbs/pipeTransport.fbs +++ b/worker/fbs/pipeTransport.fbs @@ -1,4 +1,5 @@ include "transport.fbs"; +include "srtpParameters.fbs"; namespace FBS.PipeTransport; @@ -12,18 +13,18 @@ table PipeTransportOptions { table ConnectRequest { ip:string (required); port:uint16 = null; - srtp_parameters:FBS.Transport.SrtpParameters; + srtp_parameters:FBS.SrtpParameters.SrtpParameters; } table ConnectResponse { - tuple:FBS.Transport.Tuple; + tuple:FBS.Transport.Tuple (required); } table DumpResponse { base:FBS.Transport.Dump (required); tuple:FBS.Transport.Tuple (required); rtx:bool; - srtp_parameters:FBS.Transport.SrtpParameters; + srtp_parameters:FBS.SrtpParameters.SrtpParameters; } table GetStatsResponse { diff --git a/worker/fbs/plainTransport.fbs b/worker/fbs/plainTransport.fbs index 4470d2eace..9d51a9af9d 100644 --- a/worker/fbs/plainTransport.fbs +++ b/worker/fbs/plainTransport.fbs @@ -1,5 +1,6 @@ include "transport.fbs"; include "sctpParameters.fbs"; +include "srtpParameters.fbs"; namespace FBS.PlainTransport; @@ -10,20 +11,20 @@ table PlainTransportOptions { rtcp_mux:bool; comedia:bool; enable_srtp:bool; - srtp_crypto_suite:string; + srtp_crypto_suite:FBS.SrtpParameters.SrtpCryptoSuite = null; } table ConnectRequest { ip:string; port:uint16 = null; rtcp_port:uint16 = null; - srtp_parameters:FBS.Transport.SrtpParameters; + srtp_parameters:FBS.SrtpParameters.SrtpParameters; } table ConnectResponse { tuple:FBS.Transport.Tuple (required); rtcp_tuple:FBS.Transport.Tuple; - srtp_parameters:FBS.Transport.SrtpParameters; + srtp_parameters:FBS.SrtpParameters.SrtpParameters; } table DumpResponse { @@ -32,7 +33,7 @@ table DumpResponse { comedia:bool; tuple:FBS.Transport.Tuple (required); rtcp_tuple:FBS.Transport.Tuple; - srtp_parameters:FBS.Transport.SrtpParameters; + srtp_parameters:FBS.SrtpParameters.SrtpParameters; } table GetStatsResponse { diff --git a/worker/fbs/request.fbs b/worker/fbs/request.fbs index ac1ad5fd99..7359f235ee 100644 --- a/worker/fbs/request.fbs +++ b/worker/fbs/request.fbs @@ -106,7 +106,7 @@ union Body { FBS.Transport.CloseDataConsumerRequest, PlainTransport_ConnectRequest: FBS.PlainTransport.ConnectRequest, PipeTransport_ConnectRequest: FBS.PipeTransport.ConnectRequest, - FBS.WebRtcTransport.ConnectRequest, + WebRtcTransport_ConnectRequest: FBS.WebRtcTransport.ConnectRequest, FBS.Producer.EnableTraceEventRequest, FBS.Consumer.SetPreferredLayersRequest, FBS.Consumer.SetPriorityRequest, diff --git a/worker/fbs/srtpParameters.fbs b/worker/fbs/srtpParameters.fbs new file mode 100644 index 0000000000..eb376d87c3 --- /dev/null +++ b/worker/fbs/srtpParameters.fbs @@ -0,0 +1,15 @@ + +namespace FBS.SrtpParameters; + +enum SrtpCryptoSuite: uint8 { + AEAD_AES_256_GCM, + AEAD_AES_128_GCM, + AES_CM_128_HMAC_SHA1_80, + AES_CM_128_HMAC_SHA1_32, +} + +table SrtpParameters { + crypto_suite:FBS.SrtpParameters.SrtpCryptoSuite; + key_base64:string (required); +} + diff --git a/worker/fbs/transport.fbs b/worker/fbs/transport.fbs index 5b7af3ef61..299dc42982 100644 --- a/worker/fbs/transport.fbs +++ b/worker/fbs/transport.fbs @@ -3,6 +3,7 @@ include "consumer.fbs"; include "rtpParameters.fbs"; include "sctpAssociation.fbs"; include "sctpParameters.fbs"; +include "srtpParameters.fbs"; namespace FBS.Transport; @@ -83,11 +84,6 @@ table Tuple { protocol:FBS.Transport.Protocol=UDP; } -table SrtpParameters { - crypto_suite:string (required); - key_base64:string (required); -} - table RtpListener { ssrc_table:[FBS.Common.Uint32String] (required); mid_table:[FBS.Common.StringString] (required); @@ -108,8 +104,9 @@ table RecvRtpHeaderExtensions { table Options { direct:bool = false; - max_message_size:uint32; - initial_available_outgoing_bitrate:uint32; + /// Only needed for DirectTransport. This value is handled by base Transport. + max_message_size:uint32 = null; + initial_available_outgoing_bitrate:uint32 = null; enable_sctp:bool = false; num_sctp_streams:FBS.SctpParameters.NumSctpStreams; max_sctp_message_size:uint32; @@ -155,9 +152,9 @@ table Stats { probation_send_bitrate:uint32; available_outgoing_bitrate:uint32 = null; available_incoming_bitrate:uint32 = null; - max_incoming_bitrate:uint32; - max_outgoing_bitrate:uint32; - min_outgoing_bitrate:uint32; + max_incoming_bitrate:uint32 = null; + max_outgoing_bitrate:uint32 = null; + min_outgoing_bitrate:uint32 = null; rtp_packet_loss_received:float64 = null; rtp_packet_loss_sent:float64 = null; } diff --git a/worker/fbs/webRtcTransport.fbs b/worker/fbs/webRtcTransport.fbs index 6a77106c35..002123c242 100644 --- a/worker/fbs/webRtcTransport.fbs +++ b/worker/fbs/webRtcTransport.fbs @@ -21,14 +21,36 @@ table WebRtcTransportOptions { listen:Listen (required); } +enum FingerprintAlgorithm: uint8 { + SHA1, + SHA224, + SHA256, + SHA384, + SHA512, +} + table Fingerprint { - algorithm:string (required); + algorithm:FingerprintAlgorithm; value:string (required); } +enum DtlsRole: uint8 { + AUTO, + CLIENT, + SERVER +} + +enum DtlsState: uint8 { + NEW, + CONNECTING, + CONNECTED, + FAILED, + CLOSED +} + table DtlsParameters { fingerprints:[Fingerprint] (required); - role:string; + role:DtlsRole = AUTO; } table IceParameters { @@ -37,14 +59,24 @@ table IceParameters { ice_lite:bool = true; } +enum IceCandidateType: uint8 { HOST } +enum IceCandidateTcpType: uint8 { PASSIVE } +enum IceRole: uint8 { CONTROLLED, CONTROLLING } +enum IceState: uint8 { + NEW, + CONNECTED, + COMPLETED, + DISCONNECTED, +} + table IceCandidate { foundation:string (required); priority:uint32; ip:string (required); protocol:FBS.Transport.Protocol=UDP; port:uint16; - type:string; - tcp_type:string; + type:IceCandidateType; + tcp_type:IceCandidateTcpType = null; } table ConnectRequest { @@ -52,26 +84,26 @@ table ConnectRequest { } table ConnectResponse { - dtls_local_role:string (required); + dtls_local_role:DtlsRole; } table DumpResponse { base:FBS.Transport.Dump (required); - ice_role:string (required); + ice_role:IceRole; ice_parameters:IceParameters (required); ice_candidates:[IceCandidate] (required); - ice_state:string (required); + ice_state:IceState; ice_selected_tuple:FBS.Transport.Tuple; dtls_parameters:DtlsParameters (required); - dtls_state:string (required); + dtls_state:DtlsState; } table GetStatsResponse { base:FBS.Transport.Stats (required); - ice_role:string (required); - ice_state:string (required); + ice_role:IceRole; + ice_state:IceState; ice_selected_tuple:FBS.Transport.Tuple; - dtls_state:string (required); + dtls_state:DtlsState; } // Notifications from Worker. @@ -80,9 +112,6 @@ table IceSelectedTupleChangeNotification { tuple:FBS.Transport.Tuple (required); } -enum IceState: uint8 { NEW = 0, CONNECTED, COMPLETED, DISCONNECTED, CLOSED } -enum DtlsState: uint8 { NEW = 0, CONNECTING, CONNECTED, FAILED, CLOSED } - table IceStateChangeNotification { ice_state:IceState; } diff --git a/worker/include/RTC/DtlsTransport.hpp b/worker/include/RTC/DtlsTransport.hpp index 80b03802e1..9cec6ae8f6 100644 --- a/worker/include/RTC/DtlsTransport.hpp +++ b/worker/include/RTC/DtlsTransport.hpp @@ -2,6 +2,7 @@ #define MS_RTC_DTLS_TRANSPORT_HPP #include "common.hpp" +#include "FBS/webRtcTransport_generated.h" #include "RTC/SrtpSession.hpp" #include "handles/TimerHandle.hpp" #include @@ -28,7 +29,6 @@ namespace RTC public: enum class Role { - NONE = 0, AUTO = 1, CLIENT, SERVER @@ -37,7 +37,6 @@ namespace RTC public: enum class FingerprintAlgorithm { - NONE = 0, SHA1 = 1, SHA224, SHA256, @@ -48,7 +47,7 @@ namespace RTC public: struct Fingerprint { - FingerprintAlgorithm algorithm{ FingerprintAlgorithm::NONE }; + FingerprintAlgorithm algorithm; std::string value; }; @@ -97,30 +96,11 @@ namespace RTC public: static void ClassInit(); static void ClassDestroy(); - static Role StringToRole(const std::string& role) - { - auto it = DtlsTransport::string2Role.find(role); - - if (it != DtlsTransport::string2Role.end()) - return it->second; - else - return DtlsTransport::Role::NONE; - } - static FingerprintAlgorithm GetFingerprintAlgorithm(const std::string& fingerprint) - { - auto it = DtlsTransport::string2FingerprintAlgorithm.find(fingerprint); - - if (it != DtlsTransport::string2FingerprintAlgorithm.end()) - return it->second; - else - return DtlsTransport::FingerprintAlgorithm::NONE; - } - static std::string& GetFingerprintAlgorithmString(FingerprintAlgorithm fingerprint) - { - auto it = DtlsTransport::fingerprintAlgorithm2String.find(fingerprint); - - return it->second; - } + static Role RoleFromFbs(FBS::WebRtcTransport::DtlsRole role); + static FBS::WebRtcTransport::DtlsRole RoleToFbs(Role role); + static FBS::WebRtcTransport::DtlsState StateToFbs(DtlsState state); + static FingerprintAlgorithm AlgorithmFromFbs(FBS::WebRtcTransport::FingerprintAlgorithm algorithm); + static FBS::WebRtcTransport::FingerprintAlgorithm AlgorithmToFbs(FingerprintAlgorithm algorithm); static bool IsDtls(const uint8_t* data, size_t len) { // clang-format off @@ -167,7 +147,7 @@ namespace RTC { return this->state; } - Role GetLocalRole() const + std::optional GetLocalRole() const { return this->localRole; } @@ -198,7 +178,7 @@ namespace RTC bool ProcessHandshake(); bool CheckRemoteFingerprint(); void ExtractSrtpKeys(RTC::SrtpSession::CryptoSuite srtpCryptoSuite); - RTC::SrtpSession::CryptoSuite GetNegotiatedSrtpCryptoSuite(); + std::optional GetNegotiatedSrtpCryptoSuite(); /* Callbacks fired by OpenSSL events. */ public: @@ -218,8 +198,8 @@ namespace RTC TimerHandle* timer{ nullptr }; // Others. DtlsState state{ DtlsState::NEW }; - Role localRole{ Role::NONE }; - Fingerprint remoteFingerprint; + std::optional localRole; + std::optional remoteFingerprint; bool handshakeDone{ false }; bool handshakeDoneNow{ false }; std::string remoteCert; diff --git a/worker/include/RTC/IceCandidate.hpp b/worker/include/RTC/IceCandidate.hpp index 0fef17b75d..db1a9e047b 100644 --- a/worker/include/RTC/IceCandidate.hpp +++ b/worker/include/RTC/IceCandidate.hpp @@ -27,6 +27,12 @@ namespace RTC PASSIVE = 1 }; + public: + static CandidateType CandidateTypeFromFbs(FBS::WebRtcTransport::IceCandidateType type); + static FBS::WebRtcTransport::IceCandidateType CandidateTypeToFbs(CandidateType type); + static TcpCandidateType TcpCandidateTypeFromFbs(FBS::WebRtcTransport::IceCandidateTcpType type); + static FBS::WebRtcTransport::IceCandidateTcpType TcpCandidateTypeToFbs(TcpCandidateType type); + public: IceCandidate(RTC::UdpSocket* udpSocket, uint32_t priority) : foundation("udpcandidate"), priority(priority), ip(udpSocket->GetLocalIp()), diff --git a/worker/include/RTC/IceServer.hpp b/worker/include/RTC/IceServer.hpp index 51fa85919d..acbdea2909 100644 --- a/worker/include/RTC/IceServer.hpp +++ b/worker/include/RTC/IceServer.hpp @@ -2,6 +2,7 @@ #define MS_RTC_ICE_SERVER_HPP #include "common.hpp" +#include "FBS/webRtcTransport_generated.h" #include "RTC/StunPacket.hpp" #include "RTC/TransportTuple.hpp" #include @@ -17,9 +18,13 @@ namespace RTC NEW = 1, CONNECTED, COMPLETED, - DISCONNECTED + DISCONNECTED, }; + public: + static IceState RoleFromFbs(FBS::WebRtcTransport::IceState state); + static FBS::WebRtcTransport::IceState IceStateToFbs(IceState state); + public: class Listener { diff --git a/worker/include/RTC/PlainTransport.hpp b/worker/include/RTC/PlainTransport.hpp index c0cd6f5901..5b728a406a 100644 --- a/worker/include/RTC/PlainTransport.hpp +++ b/worker/include/RTC/PlainTransport.hpp @@ -13,10 +13,6 @@ namespace RTC { class PlainTransport : public RTC::Transport, public RTC::UdpSocket::Listener { - private: - static absl::flat_hash_map string2SrtpCryptoSuite; - static absl::flat_hash_map srtpCryptoSuite2String; - public: PlainTransport( RTC::Shared* shared, diff --git a/worker/include/RTC/SrtpSession.hpp b/worker/include/RTC/SrtpSession.hpp index 7b6f34c0f0..61108b6cee 100644 --- a/worker/include/RTC/SrtpSession.hpp +++ b/worker/include/RTC/SrtpSession.hpp @@ -2,6 +2,7 @@ #define MS_RTC_SRTP_SESSION_HPP #include "common.hpp" +#include "FBS/srtpParameters_generated.h" #include namespace RTC @@ -11,8 +12,7 @@ namespace RTC public: enum class CryptoSuite { - NONE = 0, - AEAD_AES_256_GCM = 1, + AEAD_AES_256_GCM = 0, AEAD_AES_128_GCM, AES_CM_128_HMAC_SHA1_80, AES_CM_128_HMAC_SHA1_32, @@ -27,6 +27,8 @@ namespace RTC public: static void ClassInit(); + static FBS::SrtpParameters::SrtpCryptoSuite CryptoSuiteToFbs(CryptoSuite cryptoSuite); + static CryptoSuite CryptoSuiteFromFbs(FBS::SrtpParameters::SrtpCryptoSuite cryptoSuite); private: static void OnSrtpEvent(srtp_event_data_t* data); diff --git a/worker/src/Channel/ChannelSocket.cpp b/worker/src/Channel/ChannelSocket.cpp index 8d0f54bb13..abdcf11f9f 100644 --- a/worker/src/Channel/ChannelSocket.cpp +++ b/worker/src/Channel/ChannelSocket.cpp @@ -179,10 +179,11 @@ namespace Channel { const auto* message = FBS::Message::GetMessage(msg); - // TMP: For debugging. +#if MS_LOG_DEV_LEVEL == 3 auto s = flatbuffers::FlatBufferToString( reinterpret_cast(msg), FBS::Message::MessageTypeTable()); - MS_ERROR("%s", s.c_str()); + MS_DUMP("%s", s.c_str()); +#endif if (message->type() == FBS::Message::Type::REQUEST) { @@ -256,12 +257,13 @@ namespace Channel { MS_TRACE(); - auto* message = FBS::Message::GetMessage(msg); + const auto* message = FBS::Message::GetMessage(msg); - // TMP: For debugging. - // auto s = flatbuffers::FlatBufferToString( - // reinterpret_cast(msg), FBS::Message::MessageTypeTable()); - // MS_ERROR("%s", s.c_str()); +#if MS_LOG_DEV_LEVEL == 3 + auto s = flatbuffers::FlatBufferToString( + reinterpret_cast(msg), FBS::Message::MessageTypeTable()); + MS_DUMP("%s", s.c_str()); +#endif if (message->type() == FBS::Message::Type::REQUEST) { diff --git a/worker/src/RTC/DtlsTransport.cpp b/worker/src/RTC/DtlsTransport.cpp index 51413f0238..04c4d4b179 100644 --- a/worker/src/RTC/DtlsTransport.cpp +++ b/worker/src/RTC/DtlsTransport.cpp @@ -149,6 +149,101 @@ namespace RTC SSL_CTX_free(DtlsTransport::sslCtx); } + DtlsTransport::Role DtlsTransport::RoleFromFbs(FBS::WebRtcTransport::DtlsRole role) + { + switch (role) + { + case FBS::WebRtcTransport::DtlsRole::AUTO: + return DtlsTransport::Role::AUTO; + + case FBS::WebRtcTransport::DtlsRole::CLIENT: + return DtlsTransport::Role::CLIENT; + + case FBS::WebRtcTransport::DtlsRole::SERVER: + return DtlsTransport::Role::SERVER; + } + } + + FBS::WebRtcTransport::DtlsRole DtlsTransport::RoleToFbs(DtlsTransport::Role role) + { + switch (role) + { + case DtlsTransport::Role::AUTO: + return FBS::WebRtcTransport::DtlsRole::AUTO; + + case DtlsTransport::Role::CLIENT: + return FBS::WebRtcTransport::DtlsRole::CLIENT; + + case DtlsTransport::Role::SERVER: + return FBS::WebRtcTransport::DtlsRole::SERVER; + } + } + + FBS::WebRtcTransport::DtlsState DtlsTransport::StateToFbs(DtlsTransport::DtlsState state) + { + switch (state) + { + case DtlsTransport::DtlsState::NEW: + return FBS::WebRtcTransport::DtlsState::NEW; + + case DtlsTransport::DtlsState::CONNECTING: + return FBS::WebRtcTransport::DtlsState::CONNECTING; + + case DtlsTransport::DtlsState::CONNECTED: + return FBS::WebRtcTransport::DtlsState::CONNECTED; + + case DtlsTransport::DtlsState::FAILED: + return FBS::WebRtcTransport::DtlsState::FAILED; + + case DtlsTransport::DtlsState::CLOSED: + return FBS::WebRtcTransport::DtlsState::CLOSED; + } + } + + DtlsTransport::FingerprintAlgorithm DtlsTransport::AlgorithmFromFbs( + FBS::WebRtcTransport::FingerprintAlgorithm algorithm) + { + switch (algorithm) + { + case FBS::WebRtcTransport::FingerprintAlgorithm::SHA1: + return DtlsTransport::FingerprintAlgorithm::SHA1; + + case FBS::WebRtcTransport::FingerprintAlgorithm::SHA224: + return DtlsTransport::FingerprintAlgorithm::SHA224; + + case FBS::WebRtcTransport::FingerprintAlgorithm::SHA256: + return DtlsTransport::FingerprintAlgorithm::SHA256; + + case FBS::WebRtcTransport::FingerprintAlgorithm::SHA384: + return DtlsTransport::FingerprintAlgorithm::SHA384; + + case FBS::WebRtcTransport::FingerprintAlgorithm::SHA512: + return DtlsTransport::FingerprintAlgorithm::SHA512; + } + } + + FBS::WebRtcTransport::FingerprintAlgorithm DtlsTransport::AlgorithmToFbs( + DtlsTransport::FingerprintAlgorithm algorithm) + { + switch (algorithm) + { + case DtlsTransport::FingerprintAlgorithm::SHA1: + return FBS::WebRtcTransport::FingerprintAlgorithm::SHA1; + + case DtlsTransport::FingerprintAlgorithm::SHA224: + return FBS::WebRtcTransport::FingerprintAlgorithm::SHA224; + + case DtlsTransport::FingerprintAlgorithm::SHA256: + return FBS::WebRtcTransport::FingerprintAlgorithm::SHA256; + + case DtlsTransport::FingerprintAlgorithm::SHA384: + return FBS::WebRtcTransport::FingerprintAlgorithm::SHA384; + + case DtlsTransport::FingerprintAlgorithm::SHA512: + return FBS::WebRtcTransport::FingerprintAlgorithm::SHA512; + } + } + void DtlsTransport::GenerateCertificateAndPrivateKey() { MS_TRACE(); @@ -488,7 +583,7 @@ namespace RTC // Store it in the vector. DtlsTransport::Fingerprint fingerprint; - fingerprint.algorithm = DtlsTransport::GetFingerprintAlgorithm(algorithmString); + fingerprint.algorithm = algorithm; fingerprint.value = hexFingerprint; DtlsTransport::localFingerprints.push_back(fingerprint); @@ -618,18 +713,20 @@ namespace RTC default:; } - switch (this->localRole) + if (this->localRole.has_value()) { - case Role::AUTO: - role = "auto"; - break; - case Role::SERVER: - role = "server"; - break; - case Role::CLIENT: - role = "client"; - break; - default:; + switch (this->localRole.value()) + { + case Role::AUTO: + role = "auto"; + break; + case Role::SERVER: + role = "server"; + break; + case Role::CLIENT: + role = "client"; + break; + } } MS_DUMP(""); @@ -647,9 +744,7 @@ namespace RTC localRole == Role::CLIENT || localRole == Role::SERVER, "local DTLS role must be 'client' or 'server'"); - const Role previousLocalRole = this->localRole; - - if (localRole == previousLocalRole) + if (this->localRole.has_value() && localRole == this->localRole.value()) { MS_ERROR("same local DTLS role provided, doing nothing"); @@ -657,7 +752,9 @@ namespace RTC } // If the previous local DTLS role was 'client' or 'server' do reset. - if (previousLocalRole == Role::CLIENT || previousLocalRole == Role::SERVER) + if ( + this->localRole.has_value() && + (this->localRole.value() == Role::CLIENT || this->localRole.value() == Role::SERVER)) { MS_DEBUG_TAG(dtls, "resetting DTLS due to local role change"); @@ -671,7 +768,7 @@ namespace RTC this->state = DtlsState::CONNECTING; this->listener->OnDtlsTransportConnecting(this); - switch (this->localRole) + switch (this->localRole.value()) { case Role::CLIENT: { @@ -706,9 +803,6 @@ namespace RTC { MS_TRACE(); - MS_ASSERT( - fingerprint.algorithm != FingerprintAlgorithm::NONE, "no fingerprint algorithm provided"); - this->remoteFingerprint = fingerprint; // The remote fingerpring may have been set after DTLS handshake was done, @@ -840,7 +934,7 @@ namespace RTC // SendPendingOutgoingDTLSData(). SSL_shutdown(this->ssl); - this->localRole = Role::NONE; + this->localRole.reset(); this->state = DtlsState::NEW; this->handshakeDone = false; this->handshakeDoneNow = false; @@ -913,7 +1007,7 @@ namespace RTC this->timer->Stop(); // Process the handshake just once (ignore if DTLS renegotiation). - if (!wasHandshakeDone && this->remoteFingerprint.algorithm != FingerprintAlgorithm::NONE) + if (!wasHandshakeDone) return ProcessHandshake(); return true; @@ -1031,8 +1125,6 @@ namespace RTC MS_TRACE(); MS_ASSERT(this->handshakeDone, "handshake not done yet"); - MS_ASSERT( - this->remoteFingerprint.algorithm != FingerprintAlgorithm::NONE, "remote fingerprint not set"); // Validate the remote fingerprint. if (!CheckRemoteFingerprint()) @@ -1047,12 +1139,12 @@ namespace RTC } // Get the negotiated SRTP crypto suite. - RTC::SrtpSession::CryptoSuite srtpCryptoSuite = GetNegotiatedSrtpCryptoSuite(); + auto srtpCryptoSuite = GetNegotiatedSrtpCryptoSuite(); - if (srtpCryptoSuite != RTC::SrtpSession::CryptoSuite::NONE) + if (srtpCryptoSuite) { // Extract the SRTP keys (will notify the listener with them). - ExtractSrtpKeys(srtpCryptoSuite); + ExtractSrtpKeys(srtpCryptoSuite.value()); return true; } @@ -1074,8 +1166,7 @@ namespace RTC { MS_TRACE(); - MS_ASSERT( - this->remoteFingerprint.algorithm != FingerprintAlgorithm::NONE, "remote fingerprint not set"); + MS_ASSERT(this->remoteFingerprint.has_value(), "remote fingerprint not set"); X509* certificate; uint8_t binaryFingerprint[EVP_MAX_MD_SIZE]; @@ -1093,7 +1184,7 @@ namespace RTC return false; } - switch (this->remoteFingerprint.algorithm) + switch (this->remoteFingerprint->algorithm) { case FingerprintAlgorithm::SHA1: hashFunction = EVP_sha1(); @@ -1114,9 +1205,6 @@ namespace RTC case FingerprintAlgorithm::SHA512: hashFunction = EVP_sha512(); break; - - default: - MS_ABORT("unknown algorithm"); } // Compare the remote fingerprint with the value given via signaling. @@ -1138,13 +1226,13 @@ namespace RTC } hexFingerprint[(size * 3) - 1] = '\0'; - if (this->remoteFingerprint.value != hexFingerprint) + if (this->remoteFingerprint->value != hexFingerprint) { MS_WARN_TAG( dtls, "fingerprint in the remote certificate (%s) does not match the announced one (%s)", hexFingerprint, - this->remoteFingerprint.value.c_str()); + this->remoteFingerprint->value.c_str()); X509_free(certificate); @@ -1233,11 +1321,6 @@ namespace RTC break; } - - default: - { - MS_ABORT("unknown SRTP crypto suite"); - } } auto* srtpMaterial = new uint8_t[srtpMasterLength * 2]; @@ -1253,8 +1336,9 @@ namespace RTC this->ssl, srtpMaterial, srtpMasterLength * 2, "EXTRACTOR-dtls_srtp", 19, nullptr, 0, 0); MS_ASSERT(ret != 0, "SSL_export_keying_material() failed"); + MS_ASSERT(this->localRole.has_value(), "no DTLS role set"); - switch (this->localRole) + switch (this->localRole.value()) { case Role::SERVER: { @@ -1305,11 +1389,11 @@ namespace RTC delete[] srtpRemoteMasterKey; } - inline RTC::SrtpSession::CryptoSuite DtlsTransport::GetNegotiatedSrtpCryptoSuite() + inline std::optional DtlsTransport::GetNegotiatedSrtpCryptoSuite() { MS_TRACE(); - RTC::SrtpSession::CryptoSuite negotiatedSrtpCryptoSuite = RTC::SrtpSession::CryptoSuite::NONE; + std::optional negotiatedSrtpCryptoSuite; // Ensure that the SRTP crypto suite has been negotiated. // NOTE: This is a OpenSSL type. @@ -1332,8 +1416,7 @@ namespace RTC } MS_ASSERT( - negotiatedSrtpCryptoSuite != RTC::SrtpSession::CryptoSuite::NONE, - "chosen SRTP crypto suite is not an available one"); + negotiatedSrtpCryptoSuite.has_value(), "chosen SRTP crypto suite is not an available one"); return negotiatedSrtpCryptoSuite; } diff --git a/worker/src/RTC/IceCandidate.cpp b/worker/src/RTC/IceCandidate.cpp index f04aa10c21..d3e23ee978 100644 --- a/worker/src/RTC/IceCandidate.cpp +++ b/worker/src/RTC/IceCandidate.cpp @@ -6,34 +6,61 @@ namespace RTC { - /* Instance methods. */ + /* Class methods. */ - flatbuffers::Offset IceCandidate::FillBuffer( - flatbuffers::FlatBufferBuilder& builder) const + IceCandidate::CandidateType IceCandidate::CandidateTypeFromFbs( + FBS::WebRtcTransport::IceCandidateType type) { - MS_TRACE(); + switch (type) + { + case FBS::WebRtcTransport::IceCandidateType::HOST: + return IceCandidate::CandidateType::HOST; + } + } - auto protocol = TransportTuple::ProtocolToFbs(this->protocol); + FBS::WebRtcTransport::IceCandidateType IceCandidate::CandidateTypeToFbs(IceCandidate::CandidateType type) + { + switch (type) + { + case IceCandidate::CandidateType::HOST: + return FBS::WebRtcTransport::IceCandidateType::HOST; + } + } - std::string type; + IceCandidate::TcpCandidateType IceCandidate::TcpCandidateTypeFromFbs( + FBS::WebRtcTransport::IceCandidateTcpType type) + { + switch (type) + { + case FBS::WebRtcTransport::IceCandidateTcpType::PASSIVE: + return IceCandidate::TcpCandidateType::PASSIVE; + } + } - switch (this->type) + FBS::WebRtcTransport::IceCandidateTcpType IceCandidate::TcpCandidateTypeToFbs( + IceCandidate::TcpCandidateType type) + { + switch (type) { - case CandidateType::HOST: - type = "host"; - break; + case IceCandidate::TcpCandidateType::PASSIVE: + return FBS::WebRtcTransport::IceCandidateTcpType::PASSIVE; } + } + + /* Instance methods. */ - std::string tcpType; + flatbuffers::Offset IceCandidate::FillBuffer( + flatbuffers::FlatBufferBuilder& builder) const + { + MS_TRACE(); + + auto protocol = TransportTuple::ProtocolToFbs(this->protocol); + auto type = CandidateTypeToFbs(this->type); + flatbuffers::Optional tcpType; if (this->protocol == Protocol::TCP) { - switch (this->tcpType) - { - case TcpCandidateType::PASSIVE: - tcpType = "passive"; - break; - } + tcpType.emplace(TcpCandidateTypeToFbs(this->tcpType)); } return FBS::WebRtcTransport::CreateIceCandidateDirect( @@ -49,8 +76,8 @@ namespace RTC // port. this->port, // type. - type.c_str(), + type, // tcpType. - tcpType.c_str()); + tcpType); } } // namespace RTC diff --git a/worker/src/RTC/IceServer.cpp b/worker/src/RTC/IceServer.cpp index fde3d25a1b..ca215134a0 100644 --- a/worker/src/RTC/IceServer.cpp +++ b/worker/src/RTC/IceServer.cpp @@ -14,6 +14,43 @@ namespace RTC thread_local static uint8_t StunSerializeBuffer[StunSerializeBufferSize]; static constexpr size_t MaxTuples{ 8 }; + /* Class methods. */ + IceServer::IceState IceStateFromFbs(FBS::WebRtcTransport::IceState state) + { + switch (state) + { + case FBS::WebRtcTransport::IceState::NEW: + return IceServer::IceState::NEW; + + case FBS::WebRtcTransport::IceState::CONNECTED: + return IceServer::IceState::CONNECTED; + + case FBS::WebRtcTransport::IceState::COMPLETED: + return IceServer::IceState::COMPLETED; + + case FBS::WebRtcTransport::IceState::DISCONNECTED: + return IceServer::IceState::DISCONNECTED; + } + } + + FBS::WebRtcTransport::IceState IceServer::IceStateToFbs(IceServer::IceState state) + { + switch (state) + { + case IceServer::IceState::NEW: + return FBS::WebRtcTransport::IceState::NEW; + + case IceServer::IceState::CONNECTED: + return FBS::WebRtcTransport::IceState::CONNECTED; + + case IceServer::IceState::COMPLETED: + return FBS::WebRtcTransport::IceState::COMPLETED; + + case IceServer::IceState::DISCONNECTED: + return FBS::WebRtcTransport::IceState::DISCONNECTED; + } + } + /* Instance methods. */ IceServer::IceServer(Listener* listener, const std::string& usernameFragment, const std::string& password) diff --git a/worker/src/RTC/PipeTransport.cpp b/worker/src/RTC/PipeTransport.cpp index ea17fe8b3f..ebfb123ab9 100644 --- a/worker/src/RTC/PipeTransport.cpp +++ b/worker/src/RTC/PipeTransport.cpp @@ -15,7 +15,6 @@ namespace RTC RTC::SrtpSession::CryptoSuite PipeTransport::srtpCryptoSuite{ RTC::SrtpSession::CryptoSuite::AEAD_AES_256_GCM }; - std::string PipeTransport::srtpCryptoSuiteString{ "AEAD_AES_256_GCM" }; // MAster length of AEAD_AES_256_GCM. size_t PipeTransport::srtpMasterLength{ 44 }; @@ -173,12 +172,14 @@ namespace RTC } // Add srtpParameters. - flatbuffers::Offset srtpParameters; + flatbuffers::Offset srtpParameters; if (HasSrtp()) { - srtpParameters = FBS::Transport::CreateSrtpParametersDirect( - builder, PipeTransport::srtpCryptoSuiteString.c_str(), this->srtpKeyBase64.c_str()); + srtpParameters = FBS::SrtpParameters::CreateSrtpParametersDirect( + builder, + SrtpSession::CryptoSuiteToFbs(PipeTransport::srtpCryptoSuite), + this->srtpKeyBase64.c_str()); } // Add base transport dump. @@ -288,7 +289,7 @@ namespace RTC // NOTE: We just use AEAD_AES_256_GCM as SRTP crypto suite in // PipeTransport. - if (srtpParameters->cryptoSuite()->str() != PipeTransport::srtpCryptoSuiteString) + if (srtpParameters->cryptoSuite() != FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM) { MS_THROW_TYPE_ERROR("invalid/unsupported srtpParameters.cryptoSuite"); } diff --git a/worker/src/RTC/PlainTransport.cpp b/worker/src/RTC/PlainTransport.cpp index 224efc4fd2..265cd52887 100644 --- a/worker/src/RTC/PlainTransport.cpp +++ b/worker/src/RTC/PlainTransport.cpp @@ -26,22 +26,6 @@ namespace RTC /* Class variables. */ - // clang-format off - absl::flat_hash_map PlainTransport::string2SrtpCryptoSuite = - { - { "AEAD_AES_256_GCM", RTC::SrtpSession::CryptoSuite::AEAD_AES_256_GCM }, - { "AEAD_AES_128_GCM", RTC::SrtpSession::CryptoSuite::AEAD_AES_128_GCM }, - { "AES_CM_128_HMAC_SHA1_80", RTC::SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80 }, - { "AES_CM_128_HMAC_SHA1_32", RTC::SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32 } - }; - absl::flat_hash_map PlainTransport::srtpCryptoSuite2String = - { - { RTC::SrtpSession::CryptoSuite::AEAD_AES_256_GCM, "AEAD_AES_256_GCM" }, - { RTC::SrtpSession::CryptoSuite::AEAD_AES_128_GCM, "AEAD_AES_128_GCM" }, - { RTC::SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80, "AES_CM_128_HMAC_SHA1_80" }, - { RTC::SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32, "AES_CM_128_HMAC_SHA1_32" } - }; - /* Instance methods. */ PlainTransport::PlainTransport( @@ -70,12 +54,14 @@ namespace RTC this->listenInfo.port = options->listenInfo()->port(); - if (flatbuffers::IsFieldPresent(options->listenInfo(), FBS::Transport::ListenInfo::VT_SENDBUFFERSIZE)) + if (flatbuffers::IsFieldPresent( + options->listenInfo(), FBS::Transport::ListenInfo::VT_SENDBUFFERSIZE)) { this->listenInfo.sendBufferSize = options->listenInfo()->sendBufferSize(); } - if (flatbuffers::IsFieldPresent(options->listenInfo(), FBS::Transport::ListenInfo::VT_RECVBUFFERSIZE)) + if (flatbuffers::IsFieldPresent( + options->listenInfo(), FBS::Transport::ListenInfo::VT_RECVBUFFERSIZE)) { this->listenInfo.recvBufferSize = options->listenInfo()->recvBufferSize(); } @@ -85,7 +71,8 @@ namespace RTC if (!this->rtcpMux) { - if (flatbuffers::IsFieldPresent(options, FBS::PlainTransport::PlainTransportOptions::VT_RTCPLISTENINFO)) + if (flatbuffers::IsFieldPresent( + options, FBS::PlainTransport::PlainTransportOptions::VT_RTCPLISTENINFO)) { if (options->rtcpListenInfo()->protocol() != FBS::Transport::Protocol::UDP) { @@ -97,19 +84,22 @@ namespace RTC // This may throw. Utils::IP::NormalizeIp(this->rtcpListenInfo.ip); - if (flatbuffers::IsFieldPresent(options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_ANNOUNCEDIP)) + if (flatbuffers::IsFieldPresent( + options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_ANNOUNCEDIP)) { this->rtcpListenInfo.announcedIp.assign(options->rtcpListenInfo()->announcedIp()->str()); } this->rtcpListenInfo.port = options->rtcpListenInfo()->port(); - if (flatbuffers::IsFieldPresent(options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_SENDBUFFERSIZE)) + if (flatbuffers::IsFieldPresent( + options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_SENDBUFFERSIZE)) { this->rtcpListenInfo.sendBufferSize = options->rtcpListenInfo()->sendBufferSize(); } - if (flatbuffers::IsFieldPresent(options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_RECVBUFFERSIZE)) + if (flatbuffers::IsFieldPresent( + options->rtcpListenInfo(), FBS::Transport::ListenInfo::VT_RECVBUFFERSIZE)) { this->rtcpListenInfo.recvBufferSize = options->rtcpListenInfo()->recvBufferSize(); } @@ -123,22 +113,13 @@ namespace RTC if (options->enableSrtp()) { - if (!flatbuffers::IsFieldPresent( - options, FBS::PlainTransport::PlainTransportOptions::VT_SRTPCRYPTOSUITE)) + if (!options->srtpCryptoSuite().has_value()) { MS_THROW_TYPE_ERROR("missing srtpCryptoSuite"); } - // Ensure it's a crypto suite supported by us. - auto it = PlainTransport::string2SrtpCryptoSuite.find(options->srtpCryptoSuite()->str()); - - if (it == PlainTransport::string2SrtpCryptoSuite.end()) - { - MS_THROW_TYPE_ERROR("invalid/unsupported srtpCryptoSuite"); - } - // NOTE: The SRTP crypto suite may change later on connect(). - this->srtpCryptoSuite = it->second; + this->srtpCryptoSuite = SrtpSession::CryptoSuiteFromFbs(options->srtpCryptoSuite().value()); switch (this->srtpCryptoSuite) { @@ -203,7 +184,8 @@ namespace RTC // This may throw. if (this->rtcpListenInfo.port != 0) { - this->rtcpUdpSocket = new RTC::UdpSocket(this, this->rtcpListenInfo.ip, this->rtcpListenInfo.port); + this->rtcpUdpSocket = + new RTC::UdpSocket(this, this->rtcpListenInfo.ip, this->rtcpListenInfo.port); } else { @@ -296,7 +278,12 @@ namespace RTC } tuple = FBS::Transport::CreateTupleDirect( - builder, localIp.c_str(), this->udpSocket->GetLocalPort(), nullptr, 0, FBS::Transport::Protocol::UDP); + builder, + localIp.c_str(), + this->udpSocket->GetLocalPort(), + nullptr, + 0, + FBS::Transport::Protocol::UDP); } // Add rtcpTuple. @@ -322,19 +309,22 @@ namespace RTC } rtcpTuple = FBS::Transport::CreateTupleDirect( - builder, localIp.c_str(), this->rtcpUdpSocket->GetLocalPort(), nullptr, 0, FBS::Transport::Protocol::UDP); + builder, + localIp.c_str(), + this->rtcpUdpSocket->GetLocalPort(), + nullptr, + 0, + FBS::Transport::Protocol::UDP); } } // Add srtpParameters. - flatbuffers::Offset srtpParameters; + flatbuffers::Offset srtpParameters; if (HasSrtp()) { - srtpParameters = FBS::Transport::CreateSrtpParametersDirect( - builder, - PlainTransport::srtpCryptoSuite2String[this->srtpCryptoSuite].c_str(), - this->srtpKeyBase64.c_str()); + srtpParameters = FBS::SrtpParameters::CreateSrtpParametersDirect( + builder, SrtpSession::CryptoSuiteToFbs(this->srtpCryptoSuite), this->srtpKeyBase64.c_str()); } // Add base transport dump. @@ -345,7 +335,7 @@ namespace RTC } flatbuffers::Offset PlainTransport::FillBufferStats( - flatbuffers::FlatBufferBuilder& builder) + flatbuffers::FlatBufferBuilder& builder) { MS_TRACE(); @@ -360,7 +350,6 @@ namespace RTC { std::string localIp; - if (this->listenInfo.announcedIp.empty()) { localIp = this->udpSocket->GetLocalIp(); @@ -371,18 +360,17 @@ namespace RTC } tuple = FBS::Transport::CreateTupleDirect( - builder, - // localIp. - localIp.c_str(), - // localPort, - this->udpSocket->GetLocalPort(), - // remoteIp. - nullptr, - // remotePort. - 0, - // protocol. - FBS::Transport::Protocol::UDP - ); + builder, + // localIp. + localIp.c_str(), + // localPort, + this->udpSocket->GetLocalPort(), + // remoteIp. + nullptr, + // remotePort. + 0, + // protocol. + FBS::Transport::Protocol::UDP); } // Add rtcpTuple. @@ -397,12 +385,7 @@ namespace RTC auto base = Transport::FillBufferStats(builder); return FBS::PlainTransport::CreateGetStatsResponse( - builder, - base, - this->rtcpMux, - this->comedia, - tuple, - rtcpTuple); + builder, base, this->rtcpMux, this->comedia, tuple, rtcpTuple); } void PlainTransport::HandleRequest(Channel::ChannelRequest* request) @@ -444,10 +427,10 @@ namespace RTC uint16_t rtcpPort{ 0u }; std::string srtpKeyBase64; - const auto *body = request->data->body_as(); + const auto* body = request->data->body_as(); auto srtpParametersPresent = flatbuffers::IsFieldPresent( - body, FBS::PlainTransport::ConnectRequest::VT_SRTPPARAMETERS); + body, FBS::PlainTransport::ConnectRequest::VT_SRTPPARAMETERS); if (!HasSrtp() && srtpParametersPresent) { @@ -460,19 +443,11 @@ namespace RTC MS_THROW_TYPE_ERROR("missing srtpParameters (SRTP enabled)"); } - const auto *srtpParameters = body->srtpParameters(); - // Ensure it's a crypto suite supported by us. - auto it = - PlainTransport::string2SrtpCryptoSuite.find(srtpParameters->cryptoSuite()->str()); - - if (it == PlainTransport::string2SrtpCryptoSuite.end()) - { - MS_THROW_TYPE_ERROR("invalid/unsupported srtpParameters.cryptoSuite"); - } + const auto srtpParameters = body->srtpParameters(); // Update out SRTP crypto suite with the one used by the remote. auto previousSrtpCryptoSuite = this->srtpCryptoSuite; - this->srtpCryptoSuite = it->second; + this->srtpCryptoSuite = SrtpSession::CryptoSuiteFromFbs(srtpParameters->cryptoSuite()); switch (this->srtpCryptoSuite) { @@ -723,7 +698,7 @@ namespace RTC // Tell the caller about the selected local DTLS role. flatbuffers::Offset tupleOffset; flatbuffers::Offset rtcpTupleOffset; - flatbuffers::Offset srtpParametersOffset; + flatbuffers::Offset srtpParametersOffset; if (this->tuple) { @@ -737,15 +712,13 @@ namespace RTC if (HasSrtp()) { - srtpParametersOffset = FBS::Transport::CreateSrtpParametersDirect( - request->GetBufferBuilder(), - PlainTransport::srtpCryptoSuite2String[this->srtpCryptoSuite].c_str(), - this->srtpKeyBase64.c_str() - ); + srtpParametersOffset = FBS::SrtpParameters::CreateSrtpParametersDirect( + request->GetBufferBuilder(), + SrtpSession::CryptoSuiteToFbs(this->srtpCryptoSuite), + this->srtpKeyBase64.c_str()); } - auto responseOffset = - FBS::PlainTransport::CreateConnectResponse( + auto responseOffset = FBS::PlainTransport::CreateConnectResponse( request->GetBufferBuilder(), tupleOffset, rtcpTupleOffset, srtpParametersOffset); request->Accept(FBS::Response::Body::FBS_PlainTransport_ConnectResponse, responseOffset); @@ -897,7 +870,7 @@ namespace RTC { MS_TRACE(); - this->sctpAssociation->SendSctpMessage(dataConsumer, msg, len,ppid, cb); + this->sctpAssociation->SendSctpMessage(dataConsumer, msg, len, ppid, cb); } void PlainTransport::SendSctpData(const uint8_t* data, size_t len) @@ -1211,30 +1184,28 @@ namespace RTC inline void PlainTransport::EmitTuple() const { - auto tuple = this->tuple->FillBuffer(this->shared->channelNotifier->GetBufferBuilder()); + auto tuple = this->tuple->FillBuffer(this->shared->channelNotifier->GetBufferBuilder()); auto notification = FBS::PlainTransport::CreateTupleNotification( - this->shared->channelNotifier->GetBufferBuilder(), - tuple); + this->shared->channelNotifier->GetBufferBuilder(), tuple); this->shared->channelNotifier->Emit( - this->id, - FBS::Notification::Event::PLAINTRANSPORT_TUPLE, - FBS::Notification::Body::FBS_PlainTransport_TupleNotification, - notification); + this->id, + FBS::Notification::Event::PLAINTRANSPORT_TUPLE, + FBS::Notification::Body::FBS_PlainTransport_TupleNotification, + notification); } inline void PlainTransport::EmitRtcpTuple() const { auto rtcpTuple = this->rtcpTuple->FillBuffer(this->shared->channelNotifier->GetBufferBuilder()); auto notification = FBS::PlainTransport::CreateRtcpTupleNotification( - this->shared->channelNotifier->GetBufferBuilder(), - rtcpTuple); + this->shared->channelNotifier->GetBufferBuilder(), rtcpTuple); this->shared->channelNotifier->Emit( - this->id, - FBS::Notification::Event::PLAINTRANSPORT_RTCP_TUPLE, - FBS::Notification::Body::FBS_PlainTransport_RtcpTupleNotification, - notification); + this->id, + FBS::Notification::Event::PLAINTRANSPORT_RTCP_TUPLE, + FBS::Notification::Body::FBS_PlainTransport_RtcpTupleNotification, + notification); } inline void PlainTransport::OnUdpSocketPacketReceived( diff --git a/worker/src/RTC/SrtpSession.cpp b/worker/src/RTC/SrtpSession.cpp index 97051e0cfd..ee400c07eb 100644 --- a/worker/src/RTC/SrtpSession.cpp +++ b/worker/src/RTC/SrtpSession.cpp @@ -28,6 +28,42 @@ namespace RTC } } + FBS::SrtpParameters::SrtpCryptoSuite SrtpSession::CryptoSuiteToFbs(CryptoSuite cryptoSuite) + { + switch (cryptoSuite) + { + case SrtpSession::CryptoSuite::AEAD_AES_256_GCM: + return FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM; + + case SrtpSession::CryptoSuite::AEAD_AES_128_GCM: + return FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_128_GCM; + + case SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80: + return FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_80; + + case SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32: + return FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_32; + } + } + + SrtpSession::CryptoSuite SrtpSession::CryptoSuiteFromFbs(FBS::SrtpParameters::SrtpCryptoSuite cryptoSuite) + { + switch (cryptoSuite) + { + case FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM: + return SrtpSession::CryptoSuite::AEAD_AES_256_GCM; + + case FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_128_GCM: + return SrtpSession::CryptoSuite::AEAD_AES_128_GCM; + + case FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_80: + return SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_80; + + case FBS::SrtpParameters::SrtpCryptoSuite::AES_CM_128_HMAC_SHA1_32: + return SrtpSession::CryptoSuite::AES_CM_128_HMAC_SHA1_32; + } + } + void SrtpSession::OnSrtpEvent(srtp_event_data_t* data) { MS_TRACE(); diff --git a/worker/src/RTC/Transport.cpp b/worker/src/RTC/Transport.cpp index 1393ddf15a..459a852eed 100644 --- a/worker/src/RTC/Transport.cpp +++ b/worker/src/RTC/Transport.cpp @@ -44,11 +44,18 @@ namespace RTC if (options->direct()) { - this->direct = true; - this->maxMessageSize = options->maxMessageSize(); + this->direct = true; + + if (options->maxMessageSize().has_value()) + { + this->maxMessageSize = options->maxMessageSize().value(); + } } - this->initialAvailableOutgoingBitrate = options->initialAvailableOutgoingBitrate(); + if (options->initialAvailableOutgoingBitrate().has_value()) + { + this->initialAvailableOutgoingBitrate = options->initialAvailableOutgoingBitrate().value(); + } if (options->enableSctp()) { @@ -457,11 +464,14 @@ namespace RTC this->tccServer ? flatbuffers::Optional(this->tccServer->GetAvailableBitrate()) : flatbuffers::nullopt, // maxIncomingBitrate. - this->maxIncomingBitrate, + this->maxIncomingBitrate ? flatbuffers::Optional(this->maxIncomingBitrate) + : flatbuffers::nullopt, // maxOutgoingBitrate. - this->maxOutgoingBitrate, + this->maxOutgoingBitrate ? flatbuffers::Optional(this->maxOutgoingBitrate) + : flatbuffers::nullopt, // minOutgoingBitrate. - this->minOutgoingBitrate, + this->minOutgoingBitrate ? flatbuffers::Optional(this->minOutgoingBitrate) + : flatbuffers::nullopt, // packetLossReceived. this->tccServer ? flatbuffers::Optional(this->tccServer->GetPacketLoss()) : flatbuffers::nullopt, diff --git a/worker/src/RTC/WebRtcTransport.cpp b/worker/src/RTC/WebRtcTransport.cpp index f1f083f9d2..3354996011 100644 --- a/worker/src/RTC/WebRtcTransport.cpp +++ b/worker/src/RTC/WebRtcTransport.cpp @@ -316,23 +316,7 @@ namespace RTC } // Add iceState. - std::string iceState; - - switch (this->iceServer->GetState()) - { - case RTC::IceServer::IceState::NEW: - iceState = "new"; - break; - case RTC::IceServer::IceState::CONNECTED: - iceState = "connected"; - break; - case RTC::IceServer::IceState::COMPLETED: - iceState = "completed"; - break; - case RTC::IceServer::IceState::DISCONNECTED: - iceState = "disconnected"; - break; - } + auto iceState = RTC::IceServer::IceStateToFbs(this->iceServer->GetState()); // Add iceSelectedTuple. flatbuffers::Offset iceSelectedTuple; @@ -345,71 +329,33 @@ namespace RTC for (const auto& fingerprint : this->dtlsTransport->GetLocalFingerprints()) { - auto& algorithm = RTC::DtlsTransport::GetFingerprintAlgorithmString(fingerprint.algorithm); + auto algorithm = DtlsTransport::AlgorithmToFbs(fingerprint.algorithm); const auto& value = fingerprint.value; fingerprints.emplace_back( - FBS::WebRtcTransport::CreateFingerprintDirect(builder, algorithm.c_str(), value.c_str())); + FBS::WebRtcTransport::CreateFingerprintDirect(builder, algorithm, value.c_str())); } // Add dtlsParameters.role. - std::string dtlsRole; - - switch (this->dtlsRole) - { - case RTC::DtlsTransport::Role::NONE: - dtlsRole = "none"; - break; - case RTC::DtlsTransport::Role::AUTO: - dtlsRole = "auto"; - break; - case RTC::DtlsTransport::Role::CLIENT: - dtlsRole = "client"; - break; - case RTC::DtlsTransport::Role::SERVER: - dtlsRole = "server"; - break; - } - - // Add dtlsState. - std::string dtlsState; - - switch (this->dtlsTransport->GetState()) - { - case RTC::DtlsTransport::DtlsState::NEW: - dtlsState = "new"; - break; - case RTC::DtlsTransport::DtlsState::CONNECTING: - dtlsState = "connecting"; - break; - case RTC::DtlsTransport::DtlsState::CONNECTED: - dtlsState = "connected"; - break; - case RTC::DtlsTransport::DtlsState::FAILED: - dtlsState = "failed"; - break; - case RTC::DtlsTransport::DtlsState::CLOSED: - dtlsState = "closed"; - break; - } + auto dtlsRole = DtlsTransport::RoleToFbs(this->dtlsRole); + auto dtlsState = DtlsTransport::StateToFbs(this->dtlsTransport->GetState()); // Add base transport dump. auto base = Transport::FillBuffer(builder); // Add dtlsParameters. auto dtlsParameters = - FBS::WebRtcTransport::CreateDtlsParametersDirect(builder, &fingerprints, dtlsRole.c_str()); + FBS::WebRtcTransport::CreateDtlsParametersDirect(builder, &fingerprints, dtlsRole); return FBS::WebRtcTransport::CreateDumpResponseDirect( builder, base, - // iceRole (we are always "controlled"). - "controlled", + FBS::WebRtcTransport::IceRole::CONTROLLED, iceParameters, &iceCandidates, - iceState.c_str(), + iceState, iceSelectedTuple, dtlsParameters, - dtlsState.c_str()); + dtlsState); } flatbuffers::Offset WebRtcTransport::FillBufferStats( @@ -418,23 +364,7 @@ namespace RTC MS_TRACE(); // Add iceState. - std::string iceState; - - switch (this->iceServer->GetState()) - { - case RTC::IceServer::IceState::NEW: - iceState = "new"; - break; - case RTC::IceServer::IceState::CONNECTED: - iceState = "connected"; - break; - case RTC::IceServer::IceState::COMPLETED: - iceState = "completed"; - break; - case RTC::IceServer::IceState::DISCONNECTED: - iceState = "disconnected"; - break; - } + auto iceState = RTC::IceServer::IceStateToFbs(this->iceServer->GetState()); // Add iceSelectedTuple. flatbuffers::Offset iceSelectedTuple; @@ -442,39 +372,19 @@ namespace RTC if (this->iceServer->GetSelectedTuple()) iceSelectedTuple = this->iceServer->GetSelectedTuple()->FillBuffer(builder); - std::string dtlsState; - - // Add dtlsState. - switch (this->dtlsTransport->GetState()) - { - case RTC::DtlsTransport::DtlsState::NEW: - dtlsState = "new"; - break; - case RTC::DtlsTransport::DtlsState::CONNECTING: - dtlsState = "connecting"; - break; - case RTC::DtlsTransport::DtlsState::CONNECTED: - dtlsState = "connected"; - break; - case RTC::DtlsTransport::DtlsState::FAILED: - dtlsState = "failed"; - break; - case RTC::DtlsTransport::DtlsState::CLOSED: - dtlsState = "closed"; - break; - } + auto dtlsState = DtlsTransport::StateToFbs(this->dtlsTransport->GetState()); // Base Transport stats. auto base = Transport::FillBufferStats(builder); - return FBS::WebRtcTransport::CreateGetStatsResponseDirect( + return FBS::WebRtcTransport::CreateGetStatsResponse( builder, base, // iceRole (we are always "controlled"). - "controlled", - iceState.c_str(), + FBS::WebRtcTransport::IceRole::CONTROLLED, + iceState, iceSelectedTuple, - dtlsState.c_str()); + dtlsState); } void WebRtcTransport::HandleRequest(Channel::ChannelRequest* request) @@ -521,13 +431,7 @@ namespace RTC // NOTE: Just take the first fingerprint. for (const auto& fingerprint : *dtlsParameters->fingerprints()) { - dtlsRemoteFingerprint.algorithm = - RTC::DtlsTransport::GetFingerprintAlgorithm(fingerprint->algorithm()->str()); - - if (dtlsRemoteFingerprint.algorithm == RTC::DtlsTransport::FingerprintAlgorithm::NONE) - { - MS_THROW_TYPE_ERROR("invalid fingerprint.algorithm value"); - } + dtlsRemoteFingerprint.algorithm = DtlsTransport::AlgorithmFromFbs(fingerprint->algorithm()); dtlsRemoteFingerprint.value = fingerprint->value()->str(); @@ -535,17 +439,7 @@ namespace RTC break; } - if (flatbuffers::IsFieldPresent(dtlsParameters, FBS::WebRtcTransport::DtlsParameters::VT_ROLE)) - { - dtlsRemoteRole = RTC::DtlsTransport::StringToRole(dtlsParameters->role()->str()); - - if (dtlsRemoteRole == RTC::DtlsTransport::Role::NONE) - MS_THROW_TYPE_ERROR("invalid dtlsParameters.role value"); - } - else - { - dtlsRemoteRole = RTC::DtlsTransport::Role::AUTO; - } + dtlsRemoteRole = RTC::DtlsTransport::RoleFromFbs(dtlsParameters->role()); // Set local DTLS role. switch (dtlsRemoteRole) @@ -564,10 +458,6 @@ namespace RTC break; } - case RTC::DtlsTransport::Role::NONE: - { - MS_THROW_TYPE_ERROR("invalid remote DTLS role"); - } } this->connectCalled = true; @@ -580,24 +470,10 @@ namespace RTC } // Tell the caller about the selected local DTLS role. - std::string dtlsLocalRole; - - switch (this->dtlsRole) - { - case RTC::DtlsTransport::Role::CLIENT: - dtlsLocalRole = "client"; - break; + auto dtlsLocalRole = DtlsTransport::RoleToFbs(this->dtlsRole); - case RTC::DtlsTransport::Role::SERVER: - dtlsLocalRole = "server"; - break; - - default: - MS_ABORT("invalid local DTLS role"); - } - - auto responseOffset = FBS::WebRtcTransport::CreateConnectResponseDirect( - request->GetBufferBuilder(), dtlsLocalRole.c_str()); + auto responseOffset = + FBS::WebRtcTransport::CreateConnectResponse(request->GetBufferBuilder(), dtlsLocalRole); request->Accept(FBS::Response::Body::FBS_WebRtcTransport_ConnectResponse, responseOffset); @@ -778,11 +654,6 @@ namespace RTC break; } - - case RTC::DtlsTransport::Role::NONE: - { - MS_ABORT("local DTLS role not set"); - } } }