mirror of
https://mirror.ghproxy.com/https://github.com/StarCitizenToolBox/app.git
synced 2024-12-23 12:23:43 +08:00
1200 lines
38 KiB
Dart
1200 lines
38 KiB
Dart
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.6.0.
|
|
|
|
// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field
|
|
|
|
import 'api/asar_api.dart';
|
|
import 'api/go_api.dart';
|
|
import 'api/http_api.dart';
|
|
import 'api/rs_process.dart';
|
|
import 'api/win32_api.dart';
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'frb_generated.dart';
|
|
import 'frb_generated.io.dart'
|
|
if (dart.library.js_interop) 'frb_generated.web.dart';
|
|
import 'http_package.dart';
|
|
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
|
|
|
|
/// Main entrypoint of the Rust API
|
|
class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
|
|
@internal
|
|
static final instance = RustLib._();
|
|
|
|
RustLib._();
|
|
|
|
/// Initialize flutter_rust_bridge
|
|
static Future<void> init({
|
|
RustLibApi? api,
|
|
BaseHandler? handler,
|
|
ExternalLibrary? externalLibrary,
|
|
}) async {
|
|
await instance.initImpl(
|
|
api: api,
|
|
handler: handler,
|
|
externalLibrary: externalLibrary,
|
|
);
|
|
}
|
|
|
|
/// Initialize flutter_rust_bridge in mock mode.
|
|
/// No libraries for FFI are loaded.
|
|
static void initMock({
|
|
required RustLibApi api,
|
|
}) {
|
|
instance.initMockImpl(
|
|
api: api,
|
|
);
|
|
}
|
|
|
|
/// Dispose flutter_rust_bridge
|
|
///
|
|
/// The call to this function is optional, since flutter_rust_bridge (and everything else)
|
|
/// is automatically disposed when the app stops.
|
|
static void dispose() => instance.disposeImpl();
|
|
|
|
@override
|
|
ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
|
|
RustLibApiImpl.new;
|
|
|
|
@override
|
|
WireConstructor<RustLibWire> get wireConstructor =>
|
|
RustLibWire.fromExternalLibrary;
|
|
|
|
@override
|
|
Future<void> executeRustInitializers() async {}
|
|
|
|
@override
|
|
ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
|
|
kDefaultExternalLibraryLoaderConfig;
|
|
|
|
@override
|
|
String get codegenVersion => '2.6.0';
|
|
|
|
@override
|
|
int get rustContentHash => -809105468;
|
|
|
|
static const kDefaultExternalLibraryLoaderConfig =
|
|
ExternalLibraryLoaderConfig(
|
|
stem: 'rust',
|
|
ioDirectory: 'rust/target/release/',
|
|
webPrefix: 'pkg/',
|
|
);
|
|
}
|
|
|
|
abstract class RustLibApi extends BaseApi {
|
|
Future<List<String>> crateApiHttpApiDnsLookupIps({required String host});
|
|
|
|
Future<List<String>> crateApiHttpApiDnsLookupTxt({required String host});
|
|
|
|
Future<RustHttpResponse> crateApiHttpApiFetch(
|
|
{required MyMethod method,
|
|
required String url,
|
|
Map<String, String>? headers,
|
|
Uint8List? inputData,
|
|
String? withIpAddress,
|
|
bool? withCustomDns});
|
|
|
|
Future<RsiLauncherAsarData> crateApiAsarApiGetRsiLauncherAsarData(
|
|
{required String asarPath});
|
|
|
|
Future<String> crateApiGoApiPingGo({required String ping});
|
|
|
|
Future<void> crateApiAsarApiRsiLauncherAsarDataWriteMainJs(
|
|
{required RsiLauncherAsarData that, required List<int> content});
|
|
|
|
Future<void> crateApiWin32ApiSendNotify(
|
|
{String? summary, String? body, String? appName, String? appId});
|
|
|
|
Future<void> crateApiHttpApiSetDefaultHeader(
|
|
{required Map<String, String> headers});
|
|
|
|
Future<bool> crateApiWin32ApiSetForegroundWindow(
|
|
{required String windowName});
|
|
|
|
Stream<RsProcessStreamData> crateApiRsProcessStart(
|
|
{required String executable,
|
|
required List<String> arguments,
|
|
required String workingDirectory});
|
|
|
|
Future<void> crateApiRsProcessWrite(
|
|
{required int rsPid, required String data});
|
|
}
|
|
|
|
class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
|
|
RustLibApiImpl({
|
|
required super.handler,
|
|
required super.wire,
|
|
required super.generalizedFrbRustBinding,
|
|
required super.portManager,
|
|
});
|
|
|
|
@override
|
|
Future<List<String>> crateApiHttpApiDnsLookupIps({required String host}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(host);
|
|
return wire.wire__crate__api__http_api__dns_lookup_ips(port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_list_String,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiHttpApiDnsLookupIpsConstMeta,
|
|
argValues: [host],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHttpApiDnsLookupIpsConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "dns_lookup_ips",
|
|
argNames: ["host"],
|
|
);
|
|
|
|
@override
|
|
Future<List<String>> crateApiHttpApiDnsLookupTxt({required String host}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(host);
|
|
return wire.wire__crate__api__http_api__dns_lookup_txt(port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_list_String,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiHttpApiDnsLookupTxtConstMeta,
|
|
argValues: [host],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHttpApiDnsLookupTxtConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "dns_lookup_txt",
|
|
argNames: ["host"],
|
|
);
|
|
|
|
@override
|
|
Future<RustHttpResponse> crateApiHttpApiFetch(
|
|
{required MyMethod method,
|
|
required String url,
|
|
Map<String, String>? headers,
|
|
Uint8List? inputData,
|
|
String? withIpAddress,
|
|
bool? withCustomDns}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_my_method(method);
|
|
var arg1 = cst_encode_String(url);
|
|
var arg2 = cst_encode_opt_Map_String_String(headers);
|
|
var arg3 = cst_encode_opt_list_prim_u_8_strict(inputData);
|
|
var arg4 = cst_encode_opt_String(withIpAddress);
|
|
var arg5 = cst_encode_opt_box_autoadd_bool(withCustomDns);
|
|
return wire.wire__crate__api__http_api__fetch(
|
|
port_, arg0, arg1, arg2, arg3, arg4, arg5);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_rust_http_response,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiHttpApiFetchConstMeta,
|
|
argValues: [
|
|
method,
|
|
url,
|
|
headers,
|
|
inputData,
|
|
withIpAddress,
|
|
withCustomDns
|
|
],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHttpApiFetchConstMeta => const TaskConstMeta(
|
|
debugName: "fetch",
|
|
argNames: [
|
|
"method",
|
|
"url",
|
|
"headers",
|
|
"inputData",
|
|
"withIpAddress",
|
|
"withCustomDns"
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<RsiLauncherAsarData> crateApiAsarApiGetRsiLauncherAsarData(
|
|
{required String asarPath}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(asarPath);
|
|
return wire.wire__crate__api__asar_api__get_rsi_launcher_asar_data(
|
|
port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_rsi_launcher_asar_data,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiAsarApiGetRsiLauncherAsarDataConstMeta,
|
|
argValues: [asarPath],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiAsarApiGetRsiLauncherAsarDataConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "get_rsi_launcher_asar_data",
|
|
argNames: ["asarPath"],
|
|
);
|
|
|
|
@override
|
|
Future<String> crateApiGoApiPingGo({required String ping}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(ping);
|
|
return wire.wire__crate__api__go_api__ping_go(port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiGoApiPingGoConstMeta,
|
|
argValues: [ping],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiGoApiPingGoConstMeta => const TaskConstMeta(
|
|
debugName: "ping_go",
|
|
argNames: ["ping"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiAsarApiRsiLauncherAsarDataWriteMainJs(
|
|
{required RsiLauncherAsarData that, required List<int> content}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_box_autoadd_rsi_launcher_asar_data(that);
|
|
var arg1 = cst_encode_list_prim_u_8_loose(content);
|
|
return wire
|
|
.wire__crate__api__asar_api__rsi_launcher_asar_data_write_main_js(
|
|
port_, arg0, arg1);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_unit,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiAsarApiRsiLauncherAsarDataWriteMainJsConstMeta,
|
|
argValues: [that, content],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiAsarApiRsiLauncherAsarDataWriteMainJsConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rsi_launcher_asar_data_write_main_js",
|
|
argNames: ["that", "content"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiWin32ApiSendNotify(
|
|
{String? summary, String? body, String? appName, String? appId}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_opt_String(summary);
|
|
var arg1 = cst_encode_opt_String(body);
|
|
var arg2 = cst_encode_opt_String(appName);
|
|
var arg3 = cst_encode_opt_String(appId);
|
|
return wire.wire__crate__api__win32_api__send_notify(
|
|
port_, arg0, arg1, arg2, arg3);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_unit,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiWin32ApiSendNotifyConstMeta,
|
|
argValues: [summary, body, appName, appId],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiWin32ApiSendNotifyConstMeta => const TaskConstMeta(
|
|
debugName: "send_notify",
|
|
argNames: ["summary", "body", "appName", "appId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiHttpApiSetDefaultHeader(
|
|
{required Map<String, String> headers}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_Map_String_String(headers);
|
|
return wire.wire__crate__api__http_api__set_default_header(port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHttpApiSetDefaultHeaderConstMeta,
|
|
argValues: [headers],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHttpApiSetDefaultHeaderConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "set_default_header",
|
|
argNames: ["headers"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateApiWin32ApiSetForegroundWindow(
|
|
{required String windowName}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(windowName);
|
|
return wire.wire__crate__api__win32_api__set_foreground_window(
|
|
port_, arg0);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_bool,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateApiWin32ApiSetForegroundWindowConstMeta,
|
|
argValues: [windowName],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiWin32ApiSetForegroundWindowConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "set_foreground_window",
|
|
argNames: ["windowName"],
|
|
);
|
|
|
|
@override
|
|
Stream<RsProcessStreamData> crateApiRsProcessStart(
|
|
{required String executable,
|
|
required List<String> arguments,
|
|
required String workingDirectory}) {
|
|
final streamSink = RustStreamSink<RsProcessStreamData>();
|
|
unawaited(handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_String(executable);
|
|
var arg1 = cst_encode_list_String(arguments);
|
|
var arg2 = cst_encode_String(workingDirectory);
|
|
var arg3 = cst_encode_StreamSink_rs_process_stream_data_Dco(streamSink);
|
|
return wire.wire__crate__api__rs_process__start(
|
|
port_, arg0, arg1, arg2, arg3);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiRsProcessStartConstMeta,
|
|
argValues: [executable, arguments, workingDirectory, streamSink],
|
|
apiImpl: this,
|
|
)));
|
|
return streamSink.stream;
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiRsProcessStartConstMeta => const TaskConstMeta(
|
|
debugName: "start",
|
|
argNames: ["executable", "arguments", "workingDirectory", "streamSink"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiRsProcessWrite(
|
|
{required int rsPid, required String data}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
var arg0 = cst_encode_u_32(rsPid);
|
|
var arg1 = cst_encode_String(data);
|
|
return wire.wire__crate__api__rs_process__write(port_, arg0, arg1);
|
|
},
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiRsProcessWriteConstMeta,
|
|
argValues: [rsPid, data],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiRsProcessWriteConstMeta => const TaskConstMeta(
|
|
debugName: "write",
|
|
argNames: ["rsPid", "data"],
|
|
);
|
|
|
|
@protected
|
|
AnyhowException dco_decode_AnyhowException(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return AnyhowException(raw as String);
|
|
}
|
|
|
|
@protected
|
|
Map<String, String> dco_decode_Map_String_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return Map.fromEntries(dco_decode_list_record_string_string(raw)
|
|
.map((e) => MapEntry(e.$1, e.$2)));
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<RsProcessStreamData>
|
|
dco_decode_StreamSink_rs_process_stream_data_Dco(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
@protected
|
|
String dco_decode_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as String;
|
|
}
|
|
|
|
@protected
|
|
bool dco_decode_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
bool dco_decode_box_autoadd_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
RsiLauncherAsarData dco_decode_box_autoadd_rsi_launcher_asar_data(
|
|
dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_rsi_launcher_asar_data(raw);
|
|
}
|
|
|
|
@protected
|
|
BigInt dco_decode_box_autoadd_u_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_u_64(raw);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_i_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
List<String> dco_decode_list_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_String).toList();
|
|
}
|
|
|
|
@protected
|
|
List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as List<int>;
|
|
}
|
|
|
|
@protected
|
|
Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as Uint8List;
|
|
}
|
|
|
|
@protected
|
|
List<(String, String)> dco_decode_list_record_string_string(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_record_string_string).toList();
|
|
}
|
|
|
|
@protected
|
|
MyHttpVersion dco_decode_my_http_version(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return MyHttpVersion.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
MyMethod dco_decode_my_method(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return MyMethod.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
Map<String, String>? dco_decode_opt_Map_String_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_Map_String_String(raw);
|
|
}
|
|
|
|
@protected
|
|
String? dco_decode_opt_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_String(raw);
|
|
}
|
|
|
|
@protected
|
|
bool? dco_decode_opt_box_autoadd_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_bool(raw);
|
|
}
|
|
|
|
@protected
|
|
BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_u_64(raw);
|
|
}
|
|
|
|
@protected
|
|
Uint8List? dco_decode_opt_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_list_prim_u_8_strict(raw);
|
|
}
|
|
|
|
@protected
|
|
(String, String) dco_decode_record_string_string(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2) {
|
|
throw Exception('Expected 2 elements, got ${arr.length}');
|
|
}
|
|
return (
|
|
dco_decode_String(arr[0]),
|
|
dco_decode_String(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RsProcessStreamData dco_decode_rs_process_stream_data(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 3)
|
|
throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
|
|
return RsProcessStreamData(
|
|
dataType: dco_decode_rs_process_stream_data_type(arr[0]),
|
|
data: dco_decode_String(arr[1]),
|
|
rsPid: dco_decode_u_32(arr[2]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RsProcessStreamDataType dco_decode_rs_process_stream_data_type(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return RsProcessStreamDataType.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
RsiLauncherAsarData dco_decode_rsi_launcher_asar_data(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 3)
|
|
throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
|
|
return RsiLauncherAsarData(
|
|
asarPath: dco_decode_String(arr[0]),
|
|
mainJsPath: dco_decode_String(arr[1]),
|
|
mainJsContent: dco_decode_list_prim_u_8_strict(arr[2]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RustHttpResponse dco_decode_rust_http_response(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 7)
|
|
throw Exception('unexpected arr length: expect 7 but see ${arr.length}');
|
|
return RustHttpResponse(
|
|
statusCode: dco_decode_u_16(arr[0]),
|
|
headers: dco_decode_Map_String_String(arr[1]),
|
|
url: dco_decode_String(arr[2]),
|
|
contentLength: dco_decode_opt_box_autoadd_u_64(arr[3]),
|
|
version: dco_decode_my_http_version(arr[4]),
|
|
remoteAddr: dco_decode_String(arr[5]),
|
|
data: dco_decode_opt_list_prim_u_8_strict(arr[6]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_16(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
BigInt dco_decode_u_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeU64(raw);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_8(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
void dco_decode_unit(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return;
|
|
}
|
|
|
|
@protected
|
|
AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_String(deserializer);
|
|
return AnyhowException(inner);
|
|
}
|
|
|
|
@protected
|
|
Map<String, String> sse_decode_Map_String_String(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_record_string_string(deserializer);
|
|
return Map.fromEntries(inner.map((e) => MapEntry(e.$1, e.$2)));
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<RsProcessStreamData>
|
|
sse_decode_StreamSink_rs_process_stream_data_Dco(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
throw UnimplementedError('Unreachable ()');
|
|
}
|
|
|
|
@protected
|
|
String sse_decode_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return utf8.decoder.convert(inner);
|
|
}
|
|
|
|
@protected
|
|
bool sse_decode_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8() != 0;
|
|
}
|
|
|
|
@protected
|
|
bool sse_decode_box_autoadd_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_bool(deserializer));
|
|
}
|
|
|
|
@protected
|
|
RsiLauncherAsarData sse_decode_box_autoadd_rsi_launcher_asar_data(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_rsi_launcher_asar_data(deserializer));
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_u_64(deserializer));
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_i_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getInt32();
|
|
}
|
|
|
|
@protected
|
|
List<String> sse_decode_list_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <String>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_String(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
List<(String, String)> sse_decode_list_record_string_string(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <(String, String)>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_record_string_string(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
MyHttpVersion sse_decode_my_http_version(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return MyHttpVersion.values[inner];
|
|
}
|
|
|
|
@protected
|
|
MyMethod sse_decode_my_method(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return MyMethod.values[inner];
|
|
}
|
|
|
|
@protected
|
|
Map<String, String>? sse_decode_opt_Map_String_String(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_Map_String_String(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
String? sse_decode_opt_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_String(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_bool(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_u_64(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
Uint8List? sse_decode_opt_list_prim_u_8_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_list_prim_u_8_strict(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
(String, String) sse_decode_record_string_string(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_field0 = sse_decode_String(deserializer);
|
|
var var_field1 = sse_decode_String(deserializer);
|
|
return (var_field0, var_field1);
|
|
}
|
|
|
|
@protected
|
|
RsProcessStreamData sse_decode_rs_process_stream_data(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_dataType = sse_decode_rs_process_stream_data_type(deserializer);
|
|
var var_data = sse_decode_String(deserializer);
|
|
var var_rsPid = sse_decode_u_32(deserializer);
|
|
return RsProcessStreamData(
|
|
dataType: var_dataType, data: var_data, rsPid: var_rsPid);
|
|
}
|
|
|
|
@protected
|
|
RsProcessStreamDataType sse_decode_rs_process_stream_data_type(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return RsProcessStreamDataType.values[inner];
|
|
}
|
|
|
|
@protected
|
|
RsiLauncherAsarData sse_decode_rsi_launcher_asar_data(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_asarPath = sse_decode_String(deserializer);
|
|
var var_mainJsPath = sse_decode_String(deserializer);
|
|
var var_mainJsContent = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return RsiLauncherAsarData(
|
|
asarPath: var_asarPath,
|
|
mainJsPath: var_mainJsPath,
|
|
mainJsContent: var_mainJsContent);
|
|
}
|
|
|
|
@protected
|
|
RustHttpResponse sse_decode_rust_http_response(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_statusCode = sse_decode_u_16(deserializer);
|
|
var var_headers = sse_decode_Map_String_String(deserializer);
|
|
var var_url = sse_decode_String(deserializer);
|
|
var var_contentLength = sse_decode_opt_box_autoadd_u_64(deserializer);
|
|
var var_version = sse_decode_my_http_version(deserializer);
|
|
var var_remoteAddr = sse_decode_String(deserializer);
|
|
var var_data = sse_decode_opt_list_prim_u_8_strict(deserializer);
|
|
return RustHttpResponse(
|
|
statusCode: var_statusCode,
|
|
headers: var_headers,
|
|
url: var_url,
|
|
contentLength: var_contentLength,
|
|
version: var_version,
|
|
remoteAddr: var_remoteAddr,
|
|
data: var_data);
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_16(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint16();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint32();
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_u_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getBigUint64();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_8(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8();
|
|
}
|
|
|
|
@protected
|
|
void sse_decode_unit(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
bool cst_encode_bool(bool raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_i_32(int raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_my_http_version(MyHttpVersion raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return cst_encode_i_32(raw.index);
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_my_method(MyMethod raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return cst_encode_i_32(raw.index);
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_rs_process_stream_data_type(RsProcessStreamDataType raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return cst_encode_i_32(raw.index);
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_u_16(int raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_u_32(int raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
int cst_encode_u_8(int raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
void cst_encode_unit(void raw) {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
return raw;
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_AnyhowException(
|
|
AnyhowException self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.message, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_Map_String_String(
|
|
Map<String, String> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_record_string_string(
|
|
self.entries.map((e) => (e.key, e.value)).toList(), serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_StreamSink_rs_process_stream_data_Dco(
|
|
RustStreamSink<RsProcessStreamData> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: DcoCodec(
|
|
decodeSuccessData: dco_decode_rs_process_stream_data,
|
|
decodeErrorData: dco_decode_AnyhowException,
|
|
)),
|
|
serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_String(String self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_bool(bool self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self ? 1 : 0);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_bool(bool self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_bool(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_rsi_launcher_asar_data(
|
|
RsiLauncherAsarData self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_rsi_launcher_asar_data(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_64(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_i_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putInt32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_String(List<String> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_String(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_loose(
|
|
List<int> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer
|
|
.putUint8List(self is Uint8List ? self : Uint8List.fromList(self));
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_strict(
|
|
Uint8List self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer.putUint8List(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_record_string_string(
|
|
List<(String, String)> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_record_string_string(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_my_http_version(
|
|
MyHttpVersion self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_my_method(MyMethod self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_Map_String_String(
|
|
Map<String, String>? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_Map_String_String(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_String(String? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_String(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_bool(bool? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_box_autoadd_bool(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_box_autoadd_u_64(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_list_prim_u_8_strict(
|
|
Uint8List? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_list_prim_u_8_strict(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_record_string_string(
|
|
(String, String) self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.$1, serializer);
|
|
sse_encode_String(self.$2, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rs_process_stream_data(
|
|
RsProcessStreamData self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_rs_process_stream_data_type(self.dataType, serializer);
|
|
sse_encode_String(self.data, serializer);
|
|
sse_encode_u_32(self.rsPid, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rs_process_stream_data_type(
|
|
RsProcessStreamDataType self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rsi_launcher_asar_data(
|
|
RsiLauncherAsarData self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.asarPath, serializer);
|
|
sse_encode_String(self.mainJsPath, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.mainJsContent, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_http_response(
|
|
RustHttpResponse self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_16(self.statusCode, serializer);
|
|
sse_encode_Map_String_String(self.headers, serializer);
|
|
sse_encode_String(self.url, serializer);
|
|
sse_encode_opt_box_autoadd_u_64(self.contentLength, serializer);
|
|
sse_encode_my_http_version(self.version, serializer);
|
|
sse_encode_String(self.remoteAddr, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.data, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_16(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint16(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_64(BigInt self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putBigUint64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_8(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_unit(void self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
}
|