diff --git a/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h index b25e5cb44bd..728987b15c9 100644 --- a/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h +++ b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h @@ -210,21 +210,30 @@ struct MultiColumnIndexTag { // Constraint Concepts // ============================================================================= +namespace detail { + template + struct filterable_value_impl + : std::bool_constant< + std::integral || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::same_as || + std::is_enum_v> {}; + + template + struct filterable_value_impl> : filterable_value_impl> {}; +} + template -concept FilterableValue = - std::integral || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::same_as || - std::is_enum_v; +concept FilterableValue = detail::filterable_value_impl>::value; template concept AutoIncrementable = diff --git a/crates/bindings-csharp/Codegen.Tests/Tests.cs b/crates/bindings-csharp/Codegen.Tests/Tests.cs index 22c9ad13a2a..651c332b3a4 100644 --- a/crates/bindings-csharp/Codegen.Tests/Tests.cs +++ b/crates/bindings-csharp/Codegen.Tests/Tests.cs @@ -379,6 +379,33 @@ public static void TestNullableBTreeIndex(ReducerContext ctx) _ = ctx.Db.NullableBTreeIndex.AccountId.Filter(new Bound(null, 99)); } } + + [SpacetimeDB.Table] + public partial struct NullableUniqueIndex + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Unique] + public uint? AccountId; + + [SpacetimeDB.Unique] + public string? Name; + + [SpacetimeDB.Unique] + public SpacetimeDB.Uuid? ExternalId; + + [SpacetimeDB.Reducer] + public static void TestNullableUniqueIndex(ReducerContext ctx) + { + _ = ctx.Db.NullableUniqueIndex.AccountId.Find((uint?)null); + _ = ctx.Db.NullableUniqueIndex.AccountId.Find((uint?)55); + _ = ctx.Db.NullableUniqueIndex.Name.Find((string?)null); + _ = ctx.Db.NullableUniqueIndex.Name.Find("name"); + _ = ctx.Db.NullableUniqueIndex.ExternalId.Find((SpacetimeDB.Uuid?)null); + _ = ctx.Db.NullableUniqueIndex.ExternalId.Find(SpacetimeDB.Uuid.NIL); + } + } """; var parseOptions = new CSharpParseOptions(fixture.SampleCompilation.LanguageVersion); diff --git a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs index edb27202d22..7c9416faecc 100644 --- a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs +++ b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs @@ -1194,6 +1194,25 @@ public ulong Clear() => TestDefaultFieldValues, global::TestDefaultFieldValues >.DoClear(); + + public sealed class UniqueFieldUniqueIndex + : UniqueIndex< + TestDefaultFieldValues, + global::TestDefaultFieldValues, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldUniqueIndex() + : base("TestDefaultFieldValues_UniqueField_idx_btree") { } + + // Important: don't move this to the base class. + // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based + // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another. + public global::TestDefaultFieldValues? Find(int? key) => FindSingle(key); + } + + public UniqueFieldUniqueIndex UniqueField => new(); } public readonly struct TestDuplicateTableName @@ -2058,6 +2077,25 @@ public ulong Clear() => global::TestUniqueNotEquatable >.DoClear(); + public sealed class UniqueFieldUniqueIndex + : UniqueIndex< + TestUniqueNotEquatable, + global::TestUniqueNotEquatable, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldUniqueIndex() + : base("TestUniqueNotEquatable_UniqueField_idx_btree") { } + + // Important: don't move this to the base class. + // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based + // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another. + public global::TestUniqueNotEquatable? Find(int? key) => FindSingle(key); + } + + public UniqueFieldUniqueIndex UniqueField => new(); + public sealed class PrimaryKeyFieldUniqueIndex : UniqueIndex< TestUniqueNotEquatable, @@ -2890,6 +2928,22 @@ internal TestDefaultFieldValuesReadOnly() /// It also takes into account modifications by the current transaction. /// public ulong Count => DoCount(); + + public sealed class UniqueFieldIndex + : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< + global::SpacetimeDB.Internal.ViewHandles.TestDefaultFieldValuesReadOnly, + global::TestDefaultFieldValues, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldIndex() + : base("TestDefaultFieldValues_UniqueField_idx_btree") { } + + public global::TestDefaultFieldValues? Find(int? key) => FindSingle(key); + } + + public UniqueFieldIndex UniqueField => new(); } public sealed class TestDuplicateTableNameReadOnly @@ -3161,6 +3215,22 @@ internal TestUniqueNotEquatableReadOnly() /// public ulong Count => DoCount(); + public sealed class UniqueFieldIndex + : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< + global::SpacetimeDB.Internal.ViewHandles.TestUniqueNotEquatableReadOnly, + global::TestUniqueNotEquatable, + int?, + SpacetimeDB.BSATN.ValueOption + > + { + internal UniqueFieldIndex() + : base("TestUniqueNotEquatable_UniqueField_idx_btree") { } + + public global::TestUniqueNotEquatable? Find(int? key) => FindSingle(key); + } + + public UniqueFieldIndex UniqueField => new(); + public sealed class PrimaryKeyFieldIndex : global::SpacetimeDB.Internal.ReadOnlyUniqueIndex< global::SpacetimeDB.Internal.ViewHandles.TestUniqueNotEquatableReadOnly, diff --git a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt index 5978d4485c2..212e1939f21 100644 --- a/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt +++ b/crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module.verified.txt @@ -35,23 +35,6 @@ } }, {/* - [Unique] - public int? UniqueField; - ^^^^^^^^^^^ - -*/ - Message: Field UniqueField is marked as Unique but it has a type int? which is not an equatable primitive., - Severity: Error, - Descriptor: { - Id: STDB0003, - Title: Unique fields must be equatable, - MessageFormat: Field {0} is marked as Unique but it has a type {1} which is not an equatable primitive., - Category: SpacetimeDB, - DefaultSeverity: Error, - IsEnabledByDefault: true - } - }, - {/* [SpacetimeDB.Table] public partial record TestTableTaggedEnum : SpacetimeDB.TaggedEnum<(int X, int Y)> { } ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -69,23 +52,6 @@ public partial record TestTableTaggedEnum : SpacetimeDB.TaggedEnum<(int X, int Y } }, {/* - [Unique] - public int? UniqueField; - ^^^^^^^^^^^ - -*/ - Message: Field UniqueField is marked as Unique but it has a type int? which is not an equatable primitive., - Severity: Error, - Descriptor: { - Id: STDB0003, - Title: Unique fields must be equatable, - MessageFormat: Field {0} is marked as Unique but it has a type {1} which is not an equatable primitive., - Category: SpacetimeDB, - DefaultSeverity: Error, - IsEnabledByDefault: true - } - }, - {/* { [SpacetimeDB.Index.BTree(Accessor = "TestUnexpectedColumns", Columns = ["UnexpectedColumn"])] ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -626,4 +592,4 @@ public partial struct TestScheduleIssues } } ] -} +} \ No newline at end of file diff --git a/crates/bindings-csharp/Codegen/Module.cs b/crates/bindings-csharp/Codegen/Module.cs index f130a3efb05..3f24c7821cc 100644 --- a/crates/bindings-csharp/Codegen/Module.cs +++ b/crates/bindings-csharp/Codegen/Module.cs @@ -160,9 +160,22 @@ public static bool IsNoPayloadEnum(ITypeSymbol type) && variants.All(field => field.Type.ToString() == "SpacetimeDB.Unit"); } - public static bool IsEquatable(ITypeSymbol type) => - ( - IsInteger(type) + private static ITypeSymbol UnwrapNullable(ITypeSymbol type) => + type switch + { + INamedTypeSymbol + { + OriginalDefinition.SpecialType: SpecialType.System_Nullable_T + } nullable => nullable.TypeArguments[0], + _ when type.NullableAnnotation == NullableAnnotation.Annotated => + type.WithNullableAnnotation(NullableAnnotation.None), + _ => type, + }; + + public static bool IsEquatable(ITypeSymbol type) + { + type = UnwrapNullable(type); + return IsInteger(type) || IsNoPayloadEnum(type) || type.SpecialType switch { @@ -173,9 +186,8 @@ public static bool IsEquatable(ITypeSymbol type) => or "SpacetimeDB.Timestamp" or "SpacetimeDB.Uuid", _ => false, - } - ) - && type.NullableAnnotation != NullableAnnotation.Annotated; + }; + } } /// diff --git a/crates/codegen/src/csharp.rs b/crates/codegen/src/csharp.rs index 76907815898..5f06457e807 100644 --- a/crates/codegen/src/csharp.rs +++ b/crates/codegen/src/csharp.rs @@ -561,10 +561,12 @@ impl Lang for Csharp<'_> { (csharp_field_name_pascal, csharp_field_type) }; - let (row_to_key, key_type) = match columns.as_singleton() { + let (row_to_key, key_type, nullable_single_column) = match columns.as_singleton() { Some(col_pos) => { let (field_name, field_type) = get_csharp_field_name_and_type(col_pos); - (format!("row.{field_name}"), field_type.to_string()) + let field_type = field_type.to_string(); + let nullable_single_column = field_type.ends_with('?'); + (format!("row.{field_name}"), field_type, nullable_single_column) } None => { let mut key_accessors = Vec::new(); @@ -576,6 +578,7 @@ impl Lang for Csharp<'_> { ( format!("({})", key_accessors.join(", ")), format!("({})", key_type_elems.join(", ")), + false, ) } }; @@ -585,10 +588,18 @@ impl Lang for Csharp<'_> { let mut csharp_index_class_name = csharp_index_name.clone(); let csharp_index_base_class_name = if schema.is_unique(&columns) { csharp_index_class_name += "UniqueIndex"; - "UniqueIndexBase" + if nullable_single_column { + "NullableUniqueIndexBase" + } else { + "UniqueIndexBase" + } } else { csharp_index_class_name += "Index"; - "BTreeIndexBase" + if nullable_single_column { + "NullableBTreeIndexBase" + } else { + "BTreeIndexBase" + } }; writeln!( diff --git a/modules/sdk-test-cpp/src/lib.cpp b/modules/sdk-test-cpp/src/lib.cpp index 6a238395537..fd8c62c28b6 100644 --- a/modules/sdk-test-cpp/src/lib.cpp +++ b/modules/sdk-test-cpp/src/lib.cpp @@ -490,6 +490,95 @@ SPACETIMEDB_STRUCT(UniqueConnectionId, a, data) SPACETIMEDB_TABLE(UniqueConnectionId, unique_connection_id, Public) FIELD_Unique(unique_connection_id, a); +// ============================================================================= +// UNIQUE OPTIONAL CONSTRAINT TABLES - Matching Rust's UniqueOptionXXX pattern +// ============================================================================= + +struct UniqueOptionU8 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU8, n, data) +SPACETIMEDB_TABLE(UniqueOptionU8, unique_option_u8, Public) +FIELD_Unique(unique_option_u8, n); + +struct UniqueOptionU16 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU16, n, data) +SPACETIMEDB_TABLE(UniqueOptionU16, unique_option_u16, Public) +FIELD_Unique(unique_option_u16, n); + +struct UniqueOptionU32 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU32, n, data) +SPACETIMEDB_TABLE(UniqueOptionU32, unique_option_u32, Public) +FIELD_Unique(unique_option_u32, n); + +struct UniqueOptionU64 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU64, n, data) +SPACETIMEDB_TABLE(UniqueOptionU64, unique_option_u64, Public) +FIELD_Unique(unique_option_u64, n); + +struct UniqueOptionU128 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU128, n, data) +SPACETIMEDB_TABLE(UniqueOptionU128, unique_option_u128, Public) +FIELD_Unique(unique_option_u128, n); + +struct UniqueOptionU256 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionU256, n, data) +SPACETIMEDB_TABLE(UniqueOptionU256, unique_option_u256, Public) +FIELD_Unique(unique_option_u256, n); + +struct UniqueOptionI8 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI8, n, data) +SPACETIMEDB_TABLE(UniqueOptionI8, unique_option_i8, Public) +FIELD_Unique(unique_option_i8, n); + +struct UniqueOptionI16 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI16, n, data) +SPACETIMEDB_TABLE(UniqueOptionI16, unique_option_i16, Public) +FIELD_Unique(unique_option_i16, n); + +struct UniqueOptionI32 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI32, n, data) +SPACETIMEDB_TABLE(UniqueOptionI32, unique_option_i32, Public) +FIELD_Unique(unique_option_i32, n); + +struct UniqueOptionI64 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI64, n, data) +SPACETIMEDB_TABLE(UniqueOptionI64, unique_option_i64, Public) +FIELD_Unique(unique_option_i64, n); + +struct UniqueOptionI128 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI128, n, data) +SPACETIMEDB_TABLE(UniqueOptionI128, unique_option_i128, Public) +FIELD_Unique(unique_option_i128, n); + +struct UniqueOptionI256 { std::optional n; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionI256, n, data) +SPACETIMEDB_TABLE(UniqueOptionI256, unique_option_i256, Public) +FIELD_Unique(unique_option_i256, n); + +struct UniqueOptionBool { std::optional b; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionBool, b, data) +SPACETIMEDB_TABLE(UniqueOptionBool, unique_option_bool, Public) +FIELD_Unique(unique_option_bool, b); + +struct UniqueOptionString { std::optional s; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionString, s, data) +SPACETIMEDB_TABLE(UniqueOptionString, unique_option_string, Public) +FIELD_Unique(unique_option_string, s); + +struct UniqueOptionIdentity { std::optional i; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionIdentity, i, data) +SPACETIMEDB_TABLE(UniqueOptionIdentity, unique_option_identity, Public) +FIELD_Unique(unique_option_identity, i); + +struct UniqueOptionConnectionId { std::optional a; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionConnectionId, a, data) +SPACETIMEDB_TABLE(UniqueOptionConnectionId, unique_option_connection_id, Public) +FIELD_Unique(unique_option_connection_id, a); + +struct UniqueOptionUuid { std::optional u; int32_t data; }; +SPACETIMEDB_STRUCT(UniqueOptionUuid, u, data) +SPACETIMEDB_TABLE(UniqueOptionUuid, unique_option_uuid, Public) +FIELD_Unique(unique_option_uuid, u); + // ============================================================================= // PRIMARY KEY TABLES - Matching Rust's PkXXX pattern // ============================================================================= @@ -693,100 +782,202 @@ SPACETIMEDB_REDUCER(insert_one_u8, ReducerContext ctx, uint8_t n) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u8, ReducerContext ctx, uint8_t n) +{ + ctx.db[one_u8].delete_by_value(OneU8{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u16, ReducerContext ctx, uint16_t n) { ctx.db[one_u16].insert(OneU16{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u16, ReducerContext ctx, uint16_t n) +{ + ctx.db[one_u16].delete_by_value(OneU16{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u32, ReducerContext ctx, uint32_t n) { ctx.db[one_u32].insert(OneU32{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u32, ReducerContext ctx, uint32_t n) +{ + ctx.db[one_u32].delete_by_value(OneU32{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u64, ReducerContext ctx, uint64_t n) { ctx.db[one_u64].insert(OneU64{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u64, ReducerContext ctx, uint64_t n) +{ + ctx.db[one_u64].delete_by_value(OneU64{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u128, ReducerContext ctx, u128 n) { ctx.db[one_u128].insert(OneU128{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u128, ReducerContext ctx, u128 n) +{ + ctx.db[one_u128].delete_by_value(OneU128{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_u256, ReducerContext ctx, u256 n) { ctx.db[one_u256].insert(OneU256{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_u256, ReducerContext ctx, u256 n) +{ + ctx.db[one_u256].delete_by_value(OneU256{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i8, ReducerContext ctx, int8_t n) { ctx.db[one_i8].insert(OneI8{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i8, ReducerContext ctx, int8_t n) +{ + ctx.db[one_i8].delete_by_value(OneI8{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i16, ReducerContext ctx, int16_t n) { ctx.db[one_i16].insert(OneI16{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i16, ReducerContext ctx, int16_t n) +{ + ctx.db[one_i16].delete_by_value(OneI16{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i32, ReducerContext ctx, int32_t n) { ctx.db[one_i32].insert(OneI32{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i32, ReducerContext ctx, int32_t n) +{ + ctx.db[one_i32].delete_by_value(OneI32{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i64, ReducerContext ctx, int64_t n) { ctx.db[one_i64].insert(OneI64{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i64, ReducerContext ctx, int64_t n) +{ + ctx.db[one_i64].delete_by_value(OneI64{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i128, ReducerContext ctx, i128 n) { ctx.db[one_i128].insert(OneI128{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i128, ReducerContext ctx, i128 n) +{ + ctx.db[one_i128].delete_by_value(OneI128{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_i256, ReducerContext ctx, i256 n) { ctx.db[one_i256].insert(OneI256{.n = n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_i256, ReducerContext ctx, i256 n) +{ + ctx.db[one_i256].delete_by_value(OneI256{.n = n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_bool, ReducerContext ctx, bool b) { ctx.db[one_bool].insert(OneBool{.b = b}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_bool, ReducerContext ctx, bool b) +{ + ctx.db[one_bool].delete_by_value(OneBool{.b = b}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_f32, ReducerContext ctx, float f) { ctx.db[one_f32].insert(OneF32{.f = f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_f32, ReducerContext ctx, float f) +{ + ctx.db[one_f32].delete_by_value(OneF32{.f = f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_f64, ReducerContext ctx, double f) { ctx.db[one_f64].insert(OneF64{.f = f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_f64, ReducerContext ctx, double f) +{ + ctx.db[one_f64].delete_by_value(OneF64{.f = f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s) { ctx.db[one_string].insert(OneString{.s = s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_string, ReducerContext ctx, std::string s) +{ + ctx.db[one_string].delete_by_value(OneString{.s = s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_identity, ReducerContext ctx, Identity i) { ctx.db[one_identity].insert(OneIdentity{.i = i}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_identity, ReducerContext ctx, Identity i) +{ + ctx.db[one_identity].delete_by_value(OneIdentity{.i = i}); + return Ok(); } SPACETIMEDB_REDUCER(insert_one_connection_id, ReducerContext ctx, ConnectionId a) @@ -799,6 +990,12 @@ SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s) { ctx.db[one_timestamp].insert(OneTimestamp{.t = t}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_timestamp, ReducerContext ctx, Timestamp t) +{ + ctx.db[one_timestamp].delete_by_value(OneTimestamp{.t = t}); + return Ok(); } SPACETIMEDB_REDUCER(insert_one_uuid, ReducerContext ctx, Uuid u) @@ -807,6 +1004,12 @@ SPACETIMEDB_REDUCER(insert_one_uuid, ReducerContext ctx, Uuid u) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_uuid, ReducerContext ctx, Uuid u) +{ + ctx.db[one_uuid].delete_by_value(OneUuid{.u = u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_call_uuid_v4, ReducerContext ctx) { ctx.db[one_uuid].insert(OneUuid{.u = ctx.new_uuid_v4()}); @@ -825,12 +1028,24 @@ SPACETIMEDB_REDUCER(insert_one_simple_enum, ReducerContext ctx, SimpleEnum e) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_simple_enum, ReducerContext ctx, SimpleEnum e) +{ + ctx.db[one_simple_enum].delete_by_value(OneSimpleEnum{.e = e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e) { ctx.db[one_enum_with_payload].insert(OneEnumWithPayload{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e) +{ + ctx.db[one_enum_with_payload].delete_by_value(OneEnumWithPayload{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s) { fprintf(stdout, "SUCCESS: insert_one_unit_struct reducer called with UnitStruct\n"); @@ -838,22 +1053,46 @@ SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_unit_struct, ReducerContext ctx, UnitStruct s) +{ + ctx.db[one_unit_struct].delete_by_value(OneUnitStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_byte_struct, ReducerContext ctx, ByteStruct s) { ctx.db[one_byte_struct].insert(OneByteStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_byte_struct, ReducerContext ctx, ByteStruct s) +{ + ctx.db[one_byte_struct].delete_by_value(OneByteStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s) { ctx.db[one_every_primitive_struct].insert(OneEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s) +{ + ctx.db[one_every_primitive_struct].delete_by_value(OneEveryPrimitiveStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s) { ctx.db[one_every_vec_struct].insert(OneEveryVecStruct{s}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s) +{ + ctx.db[one_every_vec_struct].delete_by_value(OneEveryVecStruct{s}); + return Ok(); } // ============================================================================= @@ -866,102 +1105,204 @@ SPACETIMEDB_REDUCER(insert_vec_u8, ReducerContext ctx, std::vector n) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u8, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u8].delete_by_value(VecU8{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u16, ReducerContext ctx, std::vector n) { ctx.db[vec_u16].insert(VecU16{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u16, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u16].delete_by_value(VecU16{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u32, ReducerContext ctx, std::vector n) { ctx.db[vec_u32].insert(VecU32{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u32, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u32].delete_by_value(VecU32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u64, ReducerContext ctx, std::vector n) { ctx.db[vec_u64].insert(VecU64{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u64, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u64].delete_by_value(VecU64{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u128, ReducerContext ctx, std::vector n) { ctx.db[vec_u128].insert(VecU128{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u128, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u128].delete_by_value(VecU128{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_u256, ReducerContext ctx, std::vector n) { ctx.db[vec_u256].insert(VecU256{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_u256, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_u256].delete_by_value(VecU256{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i8, ReducerContext ctx, std::vector n) { ctx.db[vec_i8].insert(VecI8{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i8, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i8].delete_by_value(VecI8{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i16, ReducerContext ctx, std::vector n) { ctx.db[vec_i16].insert(VecI16{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i16, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i16].delete_by_value(VecI16{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i32, ReducerContext ctx, std::vector n) { ctx.db[vec_i32].insert(VecI32{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i32, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i32].delete_by_value(VecI32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i64, ReducerContext ctx, std::vector n) { ctx.db[vec_i64].insert(VecI64{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i64, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i64].delete_by_value(VecI64{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i128, ReducerContext ctx, std::vector n) { ctx.db[vec_i128].insert(VecI128{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i128, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i128].delete_by_value(VecI128{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_i256, ReducerContext ctx, std::vector n) { ctx.db[vec_i256].insert(VecI256{n}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_i256, ReducerContext ctx, std::vector n) +{ + ctx.db[vec_i256].delete_by_value(VecI256{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_bool, ReducerContext ctx, std::vector b) { ctx.db[vec_bool].insert(VecBool{b}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_bool, ReducerContext ctx, std::vector b) +{ + ctx.db[vec_bool].delete_by_value(VecBool{b}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_f32, ReducerContext ctx, std::vector f) { ctx.db[vec_f32].insert(VecF32{f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_f32, ReducerContext ctx, std::vector f) +{ + ctx.db[vec_f32].delete_by_value(VecF32{f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_f64, ReducerContext ctx, std::vector f) { ctx.db[vec_f64].insert(VecF64{f}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_f64, ReducerContext ctx, std::vector f) +{ + ctx.db[vec_f64].delete_by_value(VecF64{f}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_string, ReducerContext ctx, std::vector s) { ctx.db[vec_string].insert(VecString{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_string, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_string].delete_by_value(VecString{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_identity, ReducerContext ctx, std::vector i) { ctx.db[vec_identity].insert(VecIdentity{i}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_identity, ReducerContext ctx, std::vector i) +{ + ctx.db[vec_identity].delete_by_value(VecIdentity{i}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_connection_id, ReducerContext ctx, std::vector a) { ctx.db[vec_connection_id].insert(VecConnectionId{a}); @@ -974,46 +1315,94 @@ SPACETIMEDB_REDUCER(insert_vec_timestamp, ReducerContext ctx, std::vector t) +{ + ctx.db[vec_timestamp].delete_by_value(VecTimestamp{t}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_uuid, ReducerContext ctx, std::vector u) { ctx.db[vec_uuid].insert(VecUuid{u}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_uuid, ReducerContext ctx, std::vector u) +{ + ctx.db[vec_uuid].delete_by_value(VecUuid{u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_simple_enum, ReducerContext ctx, std::vector e) { ctx.db[vec_simple_enum].insert(VecSimpleEnum{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_simple_enum, ReducerContext ctx, std::vector e) +{ + ctx.db[vec_simple_enum].delete_by_value(VecSimpleEnum{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_enum_with_payload, ReducerContext ctx, std::vector e) { ctx.db[vec_enum_with_payload].insert(VecEnumWithPayload{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_enum_with_payload, ReducerContext ctx, std::vector e) +{ + ctx.db[vec_enum_with_payload].delete_by_value(VecEnumWithPayload{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_unit_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_unit_struct].insert(VecUnitStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_unit_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_unit_struct].delete_by_value(VecUnitStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_byte_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_byte_struct].insert(VecByteStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_byte_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_byte_struct].delete_by_value(VecByteStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_every_primitive_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_every_primitive_struct].insert(VecEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_vec_every_primitive_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_every_primitive_struct].delete_by_value(VecEveryPrimitiveStruct{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_vec_every_vec_struct, ReducerContext ctx, std::vector s) { ctx.db[vec_every_vec_struct].insert(VecEveryVecStruct{s}); return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_vec_every_vec_struct, ReducerContext ctx, std::vector s) +{ + ctx.db[vec_every_vec_struct].delete_by_value(VecEveryVecStruct{s}); + return Ok(); } // ============================================================================= @@ -1026,36 +1415,72 @@ SPACETIMEDB_REDUCER(insert_option_i32, ReducerContext ctx, std::optional n) +{ + ctx.db[option_i32].delete_by_value(OptionI32{n}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_string, ReducerContext ctx, std::optional s) { ctx.db[option_string].insert(OptionString{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_string, ReducerContext ctx, std::optional s) +{ + ctx.db[option_string].delete_by_value(OptionString{s}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_uuid, ReducerContext ctx, std::optional u) { ctx.db[option_uuid].insert(OptionUuid{u}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_uuid, ReducerContext ctx, std::optional u) +{ + ctx.db[option_uuid].delete_by_value(OptionUuid{u}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_identity, ReducerContext ctx, std::optional i) { ctx.db[option_identity].insert(OptionIdentity{i}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_identity, ReducerContext ctx, std::optional i) +{ + ctx.db[option_identity].delete_by_value(OptionIdentity{i}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_simple_enum, ReducerContext ctx, std::optional e) { ctx.db[option_simple_enum].insert(OptionSimpleEnum{e}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_simple_enum, ReducerContext ctx, std::optional e) +{ + ctx.db[option_simple_enum].delete_by_value(OptionSimpleEnum{e}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, std::optional s) { ctx.db[option_every_primitive_struct].insert(OptionEveryPrimitiveStruct{s}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_every_primitive_struct, ReducerContext ctx, std::optional s) +{ + ctx.db[option_every_primitive_struct].delete_by_value(OptionEveryPrimitiveStruct{s}); + return Ok(); +} + // Complex nested optional type - NOW FIXED! SPACETIMEDB_REDUCER(insert_option_vec_option_i32, ReducerContext ctx, std::optional>> v) { @@ -1063,6 +1488,12 @@ SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, st return Ok(); } +SPACETIMEDB_REDUCER(delete_all_option_vec_option_i32, ReducerContext ctx, std::optional>> v) +{ + ctx.db[option_vec_option_i32].delete_by_value(OptionVecOptionI32{v}); + return Ok(); +} + // ============================================================================= // RESULT TABLE REDUCERS - INSERT OPERATIONS // ============================================================================= @@ -1073,139 +1504,445 @@ SPACETIMEDB_REDUCER(insert_result_i32_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(insert_result_string_i32, ReducerContext ctx, Result r) +{ + ctx.db[result_string_i32].insert(ResultStringI32{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_identity_string, ReducerContext ctx, Result r) +{ + ctx.db[result_identity_string].insert(ResultIdentityString{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_simple_enum_i32, ReducerContext ctx, Result r) +{ + ctx.db[result_simple_enum_i32].insert(ResultSimpleEnumI32{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_every_primitive_struct_string, ReducerContext ctx, Result r) +{ + ctx.db[result_every_primitive_struct_string].insert(ResultEveryPrimitiveStructString{r}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_result_vec_i32_string, ReducerContext ctx, Result, std::string> r) +{ + ctx.db[result_vec_i32_string].insert(ResultVecI32String{r}); + return Ok(); +} + +// ============================================================================= +// UNIQUE CONSTRAINT TABLE REDUCERS +// ============================================================================= + +SPACETIMEDB_REDUCER(insert_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[unique_u8].insert(UniqueU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[unique_u8].delete_by_value(UniqueU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[unique_u16].insert(UniqueU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[unique_u16].delete_by_value(UniqueU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[unique_u32].insert(UniqueU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[unique_u32].delete_by_value(UniqueU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[unique_u64].insert(UniqueU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[unique_u64].delete_by_value(UniqueU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[unique_u128].insert(UniqueU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[unique_u128].delete_by_value(UniqueU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[unique_u256].insert(UniqueU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[unique_u256].delete_by_value(UniqueU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[unique_i8].insert(UniqueI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[unique_i8].delete_by_value(UniqueI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[unique_i16].insert(UniqueI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[unique_i16].delete_by_value(UniqueI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[unique_i32].insert(UniqueI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[unique_i32].delete_by_value(UniqueI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[unique_i64].insert(UniqueI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[unique_i64].delete_by_value(UniqueI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[unique_i128].insert(UniqueI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[unique_i128].delete_by_value(UniqueI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[unique_i256].insert(UniqueI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[unique_i256].delete_by_value(UniqueI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[unique_bool].insert(UniqueBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[unique_bool].delete_by_value(UniqueBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[unique_string].insert(UniqueString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[unique_string].delete_by_value(UniqueString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[unique_uuid].insert(UniqueUuid{u, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[unique_uuid].delete_by_value(UniqueUuid{u, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[unique_identity].insert(UniqueIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[unique_identity].delete_by_value(UniqueIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[unique_connection_id].insert(UniqueConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[unique_connection_id].delete_by_value(UniqueConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8].insert(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8].delete_by_value(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16].insert(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16].delete_by_value(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32].insert(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32].delete_by_value(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64].insert(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64].delete_by_value(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128].insert(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128].delete_by_value(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256].insert(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_all_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256].delete_by_value(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(insert_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_string_i32].insert(ResultStringI32{r}); + ctx.db[unique_option_i8].insert(UniqueOptionI8{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_identity_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(delete_all_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_identity_string].insert(ResultIdentityString{r}); + ctx.db[unique_option_i8].delete_by_value(UniqueOptionI8{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_simple_enum_i32, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(insert_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_simple_enum_i32].insert(ResultSimpleEnumI32{r}); + ctx.db[unique_option_i16].insert(UniqueOptionI16{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_every_primitive_struct_string, ReducerContext ctx, Result r) +SPACETIMEDB_REDUCER(delete_all_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_every_primitive_struct_string].insert(ResultEveryPrimitiveStructString{r}); + ctx.db[unique_option_i16].delete_by_value(UniqueOptionI16{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_result_vec_i32_string, ReducerContext ctx, Result, std::string> r) +SPACETIMEDB_REDUCER(insert_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[result_vec_i32_string].insert(ResultVecI32String{r}); + ctx.db[unique_option_i32].insert(UniqueOptionI32{n, data}); return Ok(); } -// ============================================================================= -// UNIQUE CONSTRAINT TABLE REDUCERS -// ============================================================================= - -SPACETIMEDB_REDUCER(insert_unique_u8, ReducerContext ctx, uint8_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u8].insert(UniqueU8{n, data}); + ctx.db[unique_option_i32].delete_by_value(UniqueOptionI32{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u16, ReducerContext ctx, uint16_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u16].insert(UniqueU16{n, data}); + ctx.db[unique_option_i64].insert(UniqueOptionI64{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u32, ReducerContext ctx, uint32_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u32].insert(UniqueU32{n, data}); + ctx.db[unique_option_i64].delete_by_value(UniqueOptionI64{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u64, ReducerContext ctx, uint64_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u64].insert(UniqueU64{n, data}); + ctx.db[unique_option_i128].insert(UniqueOptionI128{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u128, ReducerContext ctx, u128 n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u128].insert(UniqueU128{n, data}); + ctx.db[unique_option_i128].delete_by_value(UniqueOptionI128{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_u256, ReducerContext ctx, u256 n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_u256].insert(UniqueU256{n, data}); + ctx.db[unique_option_i256].insert(UniqueOptionI256{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i8, ReducerContext ctx, int8_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) { - ctx.db[unique_i8].insert(UniqueI8{n, data}); + ctx.db[unique_option_i256].delete_by_value(UniqueOptionI256{n, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i16, ReducerContext ctx, int16_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) { - ctx.db[unique_i16].insert(UniqueI16{n, data}); + ctx.db[unique_option_bool].insert(UniqueOptionBool{b, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i32, ReducerContext ctx, int32_t n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) { - ctx.db[unique_i32].insert(UniqueI32{n, data}); + ctx.db[unique_option_bool].delete_by_value(UniqueOptionBool{b, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i64, ReducerContext ctx, int64_t n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) { - ctx.db[unique_i64].insert(UniqueI64{n, data}); + ctx.db[unique_option_string].insert(UniqueOptionString{s, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i128, ReducerContext ctx, i128 n, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) { - ctx.db[unique_i128].insert(UniqueI128{n, data}); + ctx.db[unique_option_string].delete_by_value(UniqueOptionString{s, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_i256, ReducerContext ctx, i256 n, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) { - ctx.db[unique_i256].insert(UniqueI256{n, data}); + ctx.db[unique_option_identity].insert(UniqueOptionIdentity{i, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_bool, ReducerContext ctx, bool b, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) { - ctx.db[unique_bool].insert(UniqueBool{b, data}); + ctx.db[unique_option_identity].delete_by_value(UniqueOptionIdentity{i, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_string, ReducerContext ctx, std::string s, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) { - ctx.db[unique_string].insert(UniqueString{s, data}); + ctx.db[unique_option_connection_id].insert(UniqueOptionConnectionId{a, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_uuid, ReducerContext ctx, Uuid u, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) { - ctx.db[unique_uuid].insert(UniqueUuid{u, data}); + ctx.db[unique_option_connection_id].delete_by_value(UniqueOptionConnectionId{a, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_identity, ReducerContext ctx, Identity i, int32_t data) +SPACETIMEDB_REDUCER(insert_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) { - ctx.db[unique_identity].insert(UniqueIdentity{i, data}); + ctx.db[unique_option_uuid].insert(UniqueOptionUuid{u, data}); return Ok(); } -SPACETIMEDB_REDUCER(insert_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +SPACETIMEDB_REDUCER(delete_all_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) { - ctx.db[unique_connection_id].insert(UniqueConnectionId{a, data}); + ctx.db[unique_option_uuid].delete_by_value(UniqueOptionUuid{u, data}); return Ok(); } @@ -1219,108 +1956,216 @@ SPACETIMEDB_REDUCER(insert_pk_u8, ReducerContext ctx, uint8_t n, int32_t data) return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u8, ReducerContext ctx, uint8_t n, int32_t data) +{ + ctx.db[pk_u8].delete_by_value(PkU8{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u16, ReducerContext ctx, uint16_t n, int32_t data) { ctx.db[pk_u16].insert(PkU16{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u16, ReducerContext ctx, uint16_t n, int32_t data) +{ + ctx.db[pk_u16].delete_by_value(PkU16{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u32, ReducerContext ctx, uint32_t n, int32_t data) { ctx.db[pk_u32].insert(PkU32{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u32, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[pk_u32].delete_by_value(PkU32{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data) { ctx.db[pk_u32_two].insert(PkU32Two{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data) +{ + ctx.db[pk_u32_two].delete_by_value(PkU32Two{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u64, ReducerContext ctx, uint64_t n, int32_t data) { ctx.db[pk_u64].insert(PkU64{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u64, ReducerContext ctx, uint64_t n, int32_t data) +{ + ctx.db[pk_u64].delete_by_value(PkU64{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u128, ReducerContext ctx, u128 n, int32_t data) { ctx.db[pk_u128].insert(PkU128{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u128, ReducerContext ctx, u128 n, int32_t data) +{ + ctx.db[pk_u128].delete_by_value(PkU128{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_u256, ReducerContext ctx, u256 n, int32_t data) { ctx.db[pk_u256].insert(PkU256{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_u256, ReducerContext ctx, u256 n, int32_t data) +{ + ctx.db[pk_u256].delete_by_value(PkU256{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i8, ReducerContext ctx, int8_t n, int32_t data) { ctx.db[pk_i8].insert(PkI8{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i8, ReducerContext ctx, int8_t n, int32_t data) +{ + ctx.db[pk_i8].delete_by_value(PkI8{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i16, ReducerContext ctx, int16_t n, int32_t data) { ctx.db[pk_i16].insert(PkI16{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i16, ReducerContext ctx, int16_t n, int32_t data) +{ + ctx.db[pk_i16].delete_by_value(PkI16{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i32, ReducerContext ctx, int32_t n, int32_t data) { ctx.db[pk_i32].insert(PkI32{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i32, ReducerContext ctx, int32_t n, int32_t data) +{ + ctx.db[pk_i32].delete_by_value(PkI32{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i64, ReducerContext ctx, int64_t n, int32_t data) { ctx.db[pk_i64].insert(PkI64{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i64, ReducerContext ctx, int64_t n, int32_t data) +{ + ctx.db[pk_i64].delete_by_value(PkI64{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i128, ReducerContext ctx, i128 n, int32_t data) { ctx.db[pk_i128].insert(PkI128{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i128, ReducerContext ctx, i128 n, int32_t data) +{ + ctx.db[pk_i128].delete_by_value(PkI128{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_i256, ReducerContext ctx, i256 n, int32_t data) { ctx.db[pk_i256].insert(PkI256{n, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_i256, ReducerContext ctx, i256 n, int32_t data) +{ + ctx.db[pk_i256].delete_by_value(PkI256{n, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_bool, ReducerContext ctx, bool b, int32_t data) { ctx.db[pk_bool].insert(PkBool{b, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_bool, ReducerContext ctx, bool b, int32_t data) +{ + ctx.db[pk_bool].delete_by_value(PkBool{b, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_string, ReducerContext ctx, std::string s, int32_t data) { ctx.db[pk_string].insert(PkString{s, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_string, ReducerContext ctx, std::string s, int32_t data) +{ + ctx.db[pk_string].delete_by_value(PkString{s, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_identity, ReducerContext ctx, Identity i, int32_t data) { ctx.db[pk_identity].insert(PkIdentity{i, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_identity, ReducerContext ctx, Identity i, int32_t data) +{ + ctx.db[pk_identity].delete_by_value(PkIdentity{i, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) { ctx.db[pk_connection_id].insert(PkConnectionId{a, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data) +{ + ctx.db[pk_connection_id].delete_by_value(PkConnectionId{a, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_uuid, ReducerContext ctx, Uuid u, int32_t data) { ctx.db[pk_uuid].insert(PkUuid{u, data}); return Ok(); } +SPACETIMEDB_REDUCER(delete_all_pk_uuid, ReducerContext ctx, Uuid u, int32_t data) +{ + ctx.db[pk_uuid].delete_by_value(PkUuid{u, data}); + return Ok(); +} + SPACETIMEDB_REDUCER(insert_pk_simple_enum, ReducerContext ctx, SimpleEnum a, int32_t data) { ctx.db[pk_simple_enum].insert(PkSimpleEnum{a, data}); @@ -1580,6 +2425,108 @@ SPACETIMEDB_REDUCER(delete_unique_connection_id, ReducerContext ctx, ConnectionI return Ok(); } +SPACETIMEDB_REDUCER(delete_unique_option_u8, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u8_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u16, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u16_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u32, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u32_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u64, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u64_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u128, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u128_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_u256, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_u256_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i8, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i8_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i16, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i16_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i32, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i32_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i64, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i64_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i128, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i128_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_i256, ReducerContext ctx, std::optional n) +{ + ctx.db[unique_option_i256_n].delete_by_value(n); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_bool, ReducerContext ctx, std::optional b) +{ + ctx.db[unique_option_bool_b].delete_by_value(b); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_string, ReducerContext ctx, std::optional s) +{ + ctx.db[unique_option_string_s].delete_by_value(s); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_identity, ReducerContext ctx, std::optional i) +{ + ctx.db[unique_option_identity_i].delete_by_value(i); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_connection_id, ReducerContext ctx, std::optional a) +{ + ctx.db[unique_option_connection_id_a].delete_by_value(a); + return Ok(); +} + +SPACETIMEDB_REDUCER(delete_unique_option_uuid, ReducerContext ctx, std::optional u) +{ + ctx.db[unique_option_uuid_u].delete_by_value(u); + return Ok(); +} + // ============================================================================= // UPDATE OPERATIONS - PRIMARY KEY // ============================================================================= @@ -1840,6 +2787,108 @@ SPACETIMEDB_REDUCER(update_unique_connection_id, ReducerContext ctx, ConnectionI return Ok(); } +SPACETIMEDB_REDUCER(update_unique_option_u8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u8_n].update(UniqueOptionU8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u16_n].update(UniqueOptionU16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u32_n].update(UniqueOptionU32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u64_n].update(UniqueOptionU64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u128_n].update(UniqueOptionU128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_u256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_u256_n].update(UniqueOptionU256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i8, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i8_n].update(UniqueOptionI8{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i16, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i16_n].update(UniqueOptionI16{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i32, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i32_n].update(UniqueOptionI32{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i64, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i64_n].update(UniqueOptionI64{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i128, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i128_n].update(UniqueOptionI128{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_i256, ReducerContext ctx, std::optional n, int32_t data) +{ + ctx.db[unique_option_i256_n].update(UniqueOptionI256{n, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_bool, ReducerContext ctx, std::optional b, int32_t data) +{ + ctx.db[unique_option_bool_b].update(UniqueOptionBool{b, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_string, ReducerContext ctx, std::optional s, int32_t data) +{ + ctx.db[unique_option_string_s].update(UniqueOptionString{s, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_identity, ReducerContext ctx, std::optional i, int32_t data) +{ + ctx.db[unique_option_identity_i].update(UniqueOptionIdentity{i, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_connection_id, ReducerContext ctx, std::optional a, int32_t data) +{ + ctx.db[unique_option_connection_id_a].update(UniqueOptionConnectionId{a, data}); + return Ok(); +} + +SPACETIMEDB_REDUCER(update_unique_option_uuid, ReducerContext ctx, std::optional u, int32_t data) +{ + ctx.db[unique_option_uuid_u].update(UniqueOptionUuid{u, data}); + return Ok(); +} + // ============================================================================= // COMPREHENSIVE TABLE REDUCERS // ============================================================================= diff --git a/modules/sdk-test-cs/Lib.cs b/modules/sdk-test-cs/Lib.cs index ade952a1412..c83f19560e5 100644 --- a/modules/sdk-test-cs/Lib.cs +++ b/modules/sdk-test-cs/Lib.cs @@ -116,6 +116,12 @@ public static void insert_one_u8(ReducerContext ctx, byte n) ctx.Db.one_u8.Insert(new OneU8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u8(ReducerContext ctx, byte n) + { + ctx.Db.one_u8.Delete(new OneU8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u16", Public = true)] public partial struct OneU16 { @@ -128,6 +134,12 @@ public static void insert_one_u16(ReducerContext ctx, ushort n) ctx.Db.one_u16.Insert(new OneU16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u16(ReducerContext ctx, ushort n) + { + ctx.Db.one_u16.Delete(new OneU16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u32", Public = true)] public partial struct OneU32 { @@ -140,6 +152,12 @@ public static void insert_one_u32(ReducerContext ctx, uint n) ctx.Db.one_u32.Insert(new OneU32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u32(ReducerContext ctx, uint n) + { + ctx.Db.one_u32.Delete(new OneU32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u64", Public = true)] public partial struct OneU64 { @@ -152,6 +170,12 @@ public static void insert_one_u64(ReducerContext ctx, ulong n) ctx.Db.one_u64.Insert(new OneU64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u64(ReducerContext ctx, ulong n) + { + ctx.Db.one_u64.Delete(new OneU64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u128", Public = true)] public partial struct OneU128 { @@ -164,6 +188,12 @@ public static void insert_one_u128(ReducerContext ctx, U128 n) ctx.Db.one_u128.Insert(new OneU128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u128(ReducerContext ctx, U128 n) + { + ctx.Db.one_u128.Delete(new OneU128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_u256", Public = true)] public partial struct OneU256 { @@ -176,6 +206,12 @@ public static void insert_one_u256(ReducerContext ctx, U256 n) ctx.Db.one_u256.Insert(new OneU256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_u256(ReducerContext ctx, U256 n) + { + ctx.Db.one_u256.Delete(new OneU256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i8", Public = true)] public partial struct OneI8 { @@ -188,6 +224,12 @@ public static void insert_one_i8(ReducerContext ctx, sbyte n) ctx.Db.one_i8.Insert(new OneI8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i8(ReducerContext ctx, sbyte n) + { + ctx.Db.one_i8.Delete(new OneI8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i16", Public = true)] public partial struct OneI16 { @@ -200,6 +242,12 @@ public static void insert_one_i16(ReducerContext ctx, short n) ctx.Db.one_i16.Insert(new OneI16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i16(ReducerContext ctx, short n) + { + ctx.Db.one_i16.Delete(new OneI16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i32", Public = true)] public partial struct OneI32 { @@ -212,6 +260,12 @@ public static void insert_one_i32(ReducerContext ctx, int n) ctx.Db.one_i32.Insert(new OneI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i32(ReducerContext ctx, int n) + { + ctx.Db.one_i32.Delete(new OneI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i64", Public = true)] public partial struct OneI64 { @@ -224,6 +278,12 @@ public static void insert_one_i64(ReducerContext ctx, long n) ctx.Db.one_i64.Insert(new OneI64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i64(ReducerContext ctx, long n) + { + ctx.Db.one_i64.Delete(new OneI64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i128", Public = true)] public partial struct OneI128 { @@ -236,6 +296,12 @@ public static void insert_one_i128(ReducerContext ctx, I128 n) ctx.Db.one_i128.Insert(new OneI128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i128(ReducerContext ctx, I128 n) + { + ctx.Db.one_i128.Delete(new OneI128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_i256", Public = true)] public partial struct OneI256 { @@ -248,6 +314,12 @@ public static void insert_one_i256(ReducerContext ctx, I256 n) ctx.Db.one_i256.Insert(new OneI256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_i256(ReducerContext ctx, I256 n) + { + ctx.Db.one_i256.Delete(new OneI256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "one_bool", Public = true)] public partial struct OneBool { @@ -260,6 +332,12 @@ public static void insert_one_bool(ReducerContext ctx, bool b) ctx.Db.one_bool.Insert(new OneBool { b = b }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_bool(ReducerContext ctx, bool b) + { + ctx.Db.one_bool.Delete(new OneBool { b = b }); + } + [SpacetimeDB.Table(Accessor = "one_f32", Public = true)] public partial struct OneF32 { @@ -272,6 +350,12 @@ public static void insert_one_f32(ReducerContext ctx, float f) ctx.Db.one_f32.Insert(new OneF32 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_f32(ReducerContext ctx, float f) + { + ctx.Db.one_f32.Delete(new OneF32 { f = f }); + } + [SpacetimeDB.Table(Accessor = "one_f64", Public = true)] public partial struct OneF64 { @@ -284,6 +368,12 @@ public static void insert_one_f64(ReducerContext ctx, double f) ctx.Db.one_f64.Insert(new OneF64 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_f64(ReducerContext ctx, double f) + { + ctx.Db.one_f64.Delete(new OneF64 { f = f }); + } + [SpacetimeDB.Table(Accessor = "one_string", Public = true)] public partial struct OneString { @@ -296,6 +386,12 @@ public static void insert_one_string(ReducerContext ctx, string s) ctx.Db.one_string.Insert(new OneString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_string(ReducerContext ctx, string s) + { + ctx.Db.one_string.Delete(new OneString { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_identity", Public = true)] public partial struct OneIdentity { @@ -308,6 +404,12 @@ public static void insert_one_identity(ReducerContext ctx, Identity i) ctx.Db.one_identity.Insert(new OneIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_identity(ReducerContext ctx, Identity i) + { + ctx.Db.one_identity.Delete(new OneIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "one_connection_id", Public = true)] public partial struct OneConnectionId { @@ -332,6 +434,12 @@ public static void insert_one_uuid(ReducerContext ctx, Uuid u) ctx.Db.one_uuid.Insert(new OneUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_uuid(ReducerContext ctx, Uuid u) + { + ctx.Db.one_uuid.Delete(new OneUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "one_timestamp", Public = true)] public partial struct OneTimestamp { @@ -344,6 +452,12 @@ public static void insert_one_timestamp(ReducerContext ctx, Timestamp t) ctx.Db.one_timestamp.Insert(new OneTimestamp { t = t }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_timestamp(ReducerContext ctx, Timestamp t) + { + ctx.Db.one_timestamp.Delete(new OneTimestamp { t = t }); + } + [SpacetimeDB.Table(Accessor = "one_simple_enum", Public = true)] public partial struct OneSimpleEnum { @@ -356,6 +470,12 @@ public static void insert_one_simple_enum(ReducerContext ctx, SimpleEnum e) ctx.Db.one_simple_enum.Insert(new OneSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_simple_enum(ReducerContext ctx, SimpleEnum e) + { + ctx.Db.one_simple_enum.Delete(new OneSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "one_enum_with_payload", Public = true)] public partial struct OneEnumWithPayload { @@ -368,6 +488,12 @@ public static void insert_one_enum_with_payload(ReducerContext ctx, EnumWithPayl ctx.Db.one_enum_with_payload.Insert(new OneEnumWithPayload { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_enum_with_payload(ReducerContext ctx, EnumWithPayload e) + { + ctx.Db.one_enum_with_payload.Delete(new OneEnumWithPayload { e = e }); + } + [SpacetimeDB.Table(Accessor = "one_unit_struct", Public = true)] public partial struct OneUnitStruct { @@ -380,6 +506,12 @@ public static void insert_one_unit_struct(ReducerContext ctx, UnitStruct s) ctx.Db.one_unit_struct.Insert(new OneUnitStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_unit_struct(ReducerContext ctx, UnitStruct s) + { + ctx.Db.one_unit_struct.Delete(new OneUnitStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_byte_struct", Public = true)] public partial struct OneByteStruct { @@ -392,6 +524,12 @@ public static void insert_one_byte_struct(ReducerContext ctx, ByteStruct s) ctx.Db.one_byte_struct.Insert(new OneByteStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_byte_struct(ReducerContext ctx, ByteStruct s) + { + ctx.Db.one_byte_struct.Delete(new OneByteStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_every_primitive_struct", Public = true)] public partial struct OneEveryPrimitiveStruct { @@ -404,6 +542,12 @@ public static void insert_one_every_primitive_struct(ReducerContext ctx, EveryPr ctx.Db.one_every_primitive_struct.Insert(new OneEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_every_primitive_struct(ReducerContext ctx, EveryPrimitiveStruct s) + { + ctx.Db.one_every_primitive_struct.Delete(new OneEveryPrimitiveStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "one_every_vec_struct", Public = true)] public partial struct OneEveryVecStruct { @@ -416,6 +560,12 @@ public static void insert_one_every_vec_struct(ReducerContext ctx, EveryVecStruc ctx.Db.one_every_vec_struct.Insert(new OneEveryVecStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_one_every_vec_struct(ReducerContext ctx, EveryVecStruct s) + { + ctx.Db.one_every_vec_struct.Delete(new OneEveryVecStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_u8", Public = true)] public partial struct VecU8 { @@ -428,6 +578,12 @@ public static void insert_vec_u8(ReducerContext ctx, List n) ctx.Db.vec_u8.Insert(new VecU8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u8(ReducerContext ctx, List n) + { + ctx.Db.vec_u8.Delete(new VecU8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u16", Public = true)] public partial struct VecU16 { @@ -440,6 +596,12 @@ public static void insert_vec_u16(ReducerContext ctx, List n) ctx.Db.vec_u16.Insert(new VecU16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u16(ReducerContext ctx, List n) + { + ctx.Db.vec_u16.Delete(new VecU16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u32", Public = true)] public partial struct VecU32 { @@ -452,6 +614,12 @@ public static void insert_vec_u32(ReducerContext ctx, List n) ctx.Db.vec_u32.Insert(new VecU32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u32(ReducerContext ctx, List n) + { + ctx.Db.vec_u32.Delete(new VecU32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u64", Public = true)] public partial struct VecU64 { @@ -464,6 +632,12 @@ public static void insert_vec_u64(ReducerContext ctx, List n) ctx.Db.vec_u64.Insert(new VecU64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u64(ReducerContext ctx, List n) + { + ctx.Db.vec_u64.Delete(new VecU64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u128", Public = true)] public partial struct VecU128 { @@ -476,6 +650,12 @@ public static void insert_vec_u128(ReducerContext ctx, List n) ctx.Db.vec_u128.Insert(new VecU128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u128(ReducerContext ctx, List n) + { + ctx.Db.vec_u128.Delete(new VecU128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_u256", Public = true)] public partial struct VecU256 { @@ -488,6 +668,12 @@ public static void insert_vec_u256(ReducerContext ctx, List n) ctx.Db.vec_u256.Insert(new VecU256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_u256(ReducerContext ctx, List n) + { + ctx.Db.vec_u256.Delete(new VecU256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i8", Public = true)] public partial struct VecI8 { @@ -500,6 +686,12 @@ public static void insert_vec_i8(ReducerContext ctx, List n) ctx.Db.vec_i8.Insert(new VecI8 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i8(ReducerContext ctx, List n) + { + ctx.Db.vec_i8.Delete(new VecI8 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i16", Public = true)] public partial struct VecI16 { @@ -512,6 +704,12 @@ public static void insert_vec_i16(ReducerContext ctx, List n) ctx.Db.vec_i16.Insert(new VecI16 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i16(ReducerContext ctx, List n) + { + ctx.Db.vec_i16.Delete(new VecI16 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i32", Public = true)] public partial struct VecI32 { @@ -524,6 +722,12 @@ public static void insert_vec_i32(ReducerContext ctx, List n) ctx.Db.vec_i32.Insert(new VecI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i32(ReducerContext ctx, List n) + { + ctx.Db.vec_i32.Delete(new VecI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i64", Public = true)] public partial struct VecI64 { @@ -536,6 +740,12 @@ public static void insert_vec_i64(ReducerContext ctx, List n) ctx.Db.vec_i64.Insert(new VecI64 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i64(ReducerContext ctx, List n) + { + ctx.Db.vec_i64.Delete(new VecI64 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i128", Public = true)] public partial struct VecI128 { @@ -548,6 +758,12 @@ public static void insert_vec_i128(ReducerContext ctx, List n) ctx.Db.vec_i128.Insert(new VecI128 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i128(ReducerContext ctx, List n) + { + ctx.Db.vec_i128.Delete(new VecI128 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_i256", Public = true)] public partial struct VecI256 { @@ -560,6 +776,12 @@ public static void insert_vec_i256(ReducerContext ctx, List n) ctx.Db.vec_i256.Insert(new VecI256 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_i256(ReducerContext ctx, List n) + { + ctx.Db.vec_i256.Delete(new VecI256 { n = n }); + } + [SpacetimeDB.Table(Accessor = "vec_bool", Public = true)] public partial struct VecBool { @@ -572,6 +794,12 @@ public static void insert_vec_bool(ReducerContext ctx, List b) ctx.Db.vec_bool.Insert(new VecBool { b = b }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_bool(ReducerContext ctx, List b) + { + ctx.Db.vec_bool.Delete(new VecBool { b = b }); + } + [SpacetimeDB.Table(Accessor = "vec_f32", Public = true)] public partial struct VecF32 { @@ -584,6 +812,12 @@ public static void insert_vec_f32(ReducerContext ctx, List f) ctx.Db.vec_f32.Insert(new VecF32 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_f32(ReducerContext ctx, List f) + { + ctx.Db.vec_f32.Delete(new VecF32 { f = f }); + } + [SpacetimeDB.Table(Accessor = "vec_f64", Public = true)] public partial struct VecF64 { @@ -596,6 +830,12 @@ public static void insert_vec_f64(ReducerContext ctx, List f) ctx.Db.vec_f64.Insert(new VecF64 { f = f }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_f64(ReducerContext ctx, List f) + { + ctx.Db.vec_f64.Delete(new VecF64 { f = f }); + } + [SpacetimeDB.Table(Accessor = "vec_string", Public = true)] public partial struct VecString { @@ -608,6 +848,12 @@ public static void insert_vec_string(ReducerContext ctx, List s) ctx.Db.vec_string.Insert(new VecString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_string(ReducerContext ctx, List s) + { + ctx.Db.vec_string.Delete(new VecString { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_identity", Public = true)] public partial struct VecIdentity { @@ -620,6 +866,12 @@ public static void insert_vec_identity(ReducerContext ctx, List i) ctx.Db.vec_identity.Insert(new VecIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_identity(ReducerContext ctx, List i) + { + ctx.Db.vec_identity.Delete(new VecIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "vec_connection_id", Public = true)] public partial struct VecConnectionId { @@ -644,6 +896,12 @@ public static void insert_vec_uuid(ReducerContext ctx, List u) ctx.Db.vec_uuid.Insert(new VecUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_uuid(ReducerContext ctx, List u) + { + ctx.Db.vec_uuid.Delete(new VecUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "vec_timestamp", Public = true)] public partial struct VecTimestamp { @@ -656,6 +914,12 @@ public static void insert_vec_timestamp(ReducerContext ctx, List t) ctx.Db.vec_timestamp.Insert(new VecTimestamp { t = t }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_timestamp(ReducerContext ctx, List t) + { + ctx.Db.vec_timestamp.Delete(new VecTimestamp { t = t }); + } + [SpacetimeDB.Table(Accessor = "vec_simple_enum", Public = true)] public partial struct VecSimpleEnum { @@ -668,6 +932,12 @@ public static void insert_vec_simple_enum(ReducerContext ctx, List e ctx.Db.vec_simple_enum.Insert(new VecSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_simple_enum(ReducerContext ctx, List e) + { + ctx.Db.vec_simple_enum.Delete(new VecSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "vec_enum_with_payload", Public = true)] public partial struct VecEnumWithPayload { @@ -680,6 +950,12 @@ public static void insert_vec_enum_with_payload(ReducerContext ctx, List e) + { + ctx.Db.vec_enum_with_payload.Delete(new VecEnumWithPayload { e = e }); + } + [SpacetimeDB.Table(Accessor = "vec_unit_struct", Public = true)] public partial struct VecUnitStruct { @@ -692,6 +968,12 @@ public static void insert_vec_unit_struct(ReducerContext ctx, List s ctx.Db.vec_unit_struct.Insert(new VecUnitStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_unit_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_unit_struct.Delete(new VecUnitStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_byte_struct", Public = true)] public partial struct VecByteStruct { @@ -704,6 +986,12 @@ public static void insert_vec_byte_struct(ReducerContext ctx, List s ctx.Db.vec_byte_struct.Insert(new VecByteStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_byte_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_byte_struct.Delete(new VecByteStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_every_primitive_struct", Public = true)] public partial struct VecEveryPrimitiveStruct { @@ -719,6 +1007,15 @@ List s ctx.Db.vec_every_primitive_struct.Insert(new VecEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_vec_every_primitive_struct( + ReducerContext ctx, + List s + ) + { + ctx.Db.vec_every_primitive_struct.Delete(new VecEveryPrimitiveStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "vec_every_vec_struct", Public = true)] public partial struct VecEveryVecStruct { @@ -731,6 +1028,12 @@ public static void insert_vec_every_vec_struct(ReducerContext ctx, List s) + { + ctx.Db.vec_every_vec_struct.Delete(new VecEveryVecStruct { s = s }); + } + [SpacetimeDB.Table(Accessor = "option_i32", Public = true)] public partial struct OptionI32 { @@ -743,6 +1046,12 @@ public static void insert_option_i32(ReducerContext ctx, int? n) ctx.Db.option_i32.Insert(new OptionI32 { n = n }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_i32(ReducerContext ctx, int? n) + { + ctx.Db.option_i32.Delete(new OptionI32 { n = n }); + } + [SpacetimeDB.Table(Accessor = "option_string", Public = true)] public partial struct OptionString { @@ -755,6 +1064,12 @@ public static void insert_option_string(ReducerContext ctx, string? s) ctx.Db.option_string.Insert(new OptionString { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_string(ReducerContext ctx, string? s) + { + ctx.Db.option_string.Delete(new OptionString { s = s }); + } + [SpacetimeDB.Table(Accessor = "option_identity", Public = true)] public partial struct OptionIdentity { @@ -767,6 +1082,12 @@ public static void insert_option_identity(ReducerContext ctx, Identity? i) ctx.Db.option_identity.Insert(new OptionIdentity { i = i }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_identity(ReducerContext ctx, Identity? i) + { + ctx.Db.option_identity.Delete(new OptionIdentity { i = i }); + } + [SpacetimeDB.Table(Accessor = "option_uuid", Public = true)] public partial struct OptionUuid { @@ -779,6 +1100,12 @@ public static void insert_option_uuid(ReducerContext ctx, Uuid? u) ctx.Db.option_uuid.Insert(new OptionUuid { u = u }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_uuid(ReducerContext ctx, Uuid? u) + { + ctx.Db.option_uuid.Delete(new OptionUuid { u = u }); + } + [SpacetimeDB.Table(Accessor = "option_simple_enum", Public = true)] public partial struct OptionSimpleEnum { @@ -791,6 +1118,12 @@ public static void insert_option_simple_enum(ReducerContext ctx, SimpleEnum? e) ctx.Db.option_simple_enum.Insert(new OptionSimpleEnum { e = e }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_simple_enum(ReducerContext ctx, SimpleEnum? e) + { + ctx.Db.option_simple_enum.Delete(new OptionSimpleEnum { e = e }); + } + [SpacetimeDB.Table(Accessor = "option_every_primitive_struct", Public = true)] public partial struct OptionEveryPrimitiveStruct { @@ -806,6 +1139,15 @@ public static void insert_option_every_primitive_struct( ctx.Db.option_every_primitive_struct.Insert(new OptionEveryPrimitiveStruct { s = s }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_every_primitive_struct( + ReducerContext ctx, + EveryPrimitiveStruct? s + ) + { + ctx.Db.option_every_primitive_struct.Delete(new OptionEveryPrimitiveStruct { s = s }); + } + [Table(Accessor = "result_i32_string", Public = true)] public partial struct ResultI32String { @@ -898,6 +1240,12 @@ public static void insert_option_vec_option_i32(ReducerContext ctx, List? ctx.Db.option_vec_option_i32.Insert(new OptionVecOptionI32 { v = v }); } + [SpacetimeDB.Reducer] + public static void delete_all_option_vec_option_i32(ReducerContext ctx, List? v) + { + ctx.Db.option_vec_option_i32.Delete(new OptionVecOptionI32 { v = v }); + } + [SpacetimeDB.Table(Accessor = "unique_u8", Public = true)] public partial struct UniqueU8 { @@ -912,6 +1260,12 @@ public static void insert_unique_u8(ReducerContext ctx, byte n, int data) ctx.Db.unique_u8.Insert(new UniqueU8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u8(ReducerContext ctx, byte n, int data) + { + ctx.Db.unique_u8.Delete(new UniqueU8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u8(ReducerContext ctx, byte n, int data) { @@ -939,6 +1293,12 @@ public static void insert_unique_u16(ReducerContext ctx, ushort n, int data) ctx.Db.unique_u16.Insert(new UniqueU16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u16(ReducerContext ctx, ushort n, int data) + { + ctx.Db.unique_u16.Delete(new UniqueU16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u16(ReducerContext ctx, ushort n, int data) { @@ -966,6 +1326,12 @@ public static void insert_unique_u32(ReducerContext ctx, uint n, int data) ctx.Db.unique_u32.Insert(new UniqueU32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u32(ReducerContext ctx, uint n, int data) + { + ctx.Db.unique_u32.Delete(new UniqueU32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void insert_unique_u32_update_pk_u32( ReducerContext ctx, @@ -1005,6 +1371,12 @@ public static void insert_unique_u64(ReducerContext ctx, ulong n, int data) ctx.Db.unique_u64.Insert(new UniqueU64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u64(ReducerContext ctx, ulong n, int data) + { + ctx.Db.unique_u64.Delete(new UniqueU64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u64(ReducerContext ctx, ulong n, int data) { @@ -1032,6 +1404,12 @@ public static void insert_unique_u128(ReducerContext ctx, U128 n, int data) ctx.Db.unique_u128.Insert(new UniqueU128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_u128(ReducerContext ctx, U128 n, int data) + { + ctx.Db.unique_u128.Delete(new UniqueU128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_u128(ReducerContext ctx, U128 n, int data) { @@ -1060,9 +1438,15 @@ public static void insert_unique_u256(ReducerContext ctx, U256 n, int data) } [SpacetimeDB.Reducer] - public static void update_unique_u256(ReducerContext ctx, U256 n, int data) + public static void delete_all_unique_u256(ReducerContext ctx, U256 n, int data) { - ctx.Db.unique_u256.n.Delete(n); + ctx.Db.unique_u256.Delete(new UniqueU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_u256(ReducerContext ctx, U256 n, int data) + { + ctx.Db.unique_u256.n.Delete(n); ctx.Db.unique_u256.Insert(new UniqueU256 { n = n, data = data }); } @@ -1086,6 +1470,12 @@ public static void insert_unique_i8(ReducerContext ctx, sbyte n, int data) ctx.Db.unique_i8.Insert(new UniqueI8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i8(ReducerContext ctx, sbyte n, int data) + { + ctx.Db.unique_i8.Delete(new UniqueI8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i8(ReducerContext ctx, sbyte n, int data) { @@ -1113,6 +1503,12 @@ public static void insert_unique_i16(ReducerContext ctx, short n, int data) ctx.Db.unique_i16.Insert(new UniqueI16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i16(ReducerContext ctx, short n, int data) + { + ctx.Db.unique_i16.Delete(new UniqueI16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i16(ReducerContext ctx, short n, int data) { @@ -1140,6 +1536,12 @@ public static void insert_unique_i32(ReducerContext ctx, int n, int data) ctx.Db.unique_i32.Insert(new UniqueI32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i32(ReducerContext ctx, int n, int data) + { + ctx.Db.unique_i32.Delete(new UniqueI32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i32(ReducerContext ctx, int n, int data) { @@ -1167,6 +1569,12 @@ public static void insert_unique_i64(ReducerContext ctx, long n, int data) ctx.Db.unique_i64.Insert(new UniqueI64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i64(ReducerContext ctx, long n, int data) + { + ctx.Db.unique_i64.Delete(new UniqueI64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i64(ReducerContext ctx, long n, int data) { @@ -1194,6 +1602,12 @@ public static void insert_unique_i128(ReducerContext ctx, I128 n, int data) ctx.Db.unique_i128.Insert(new UniqueI128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i128(ReducerContext ctx, I128 n, int data) + { + ctx.Db.unique_i128.Delete(new UniqueI128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i128(ReducerContext ctx, I128 n, int data) { @@ -1221,6 +1635,12 @@ public static void insert_unique_i256(ReducerContext ctx, I256 n, int data) ctx.Db.unique_i256.Insert(new UniqueI256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_i256(ReducerContext ctx, I256 n, int data) + { + ctx.Db.unique_i256.Delete(new UniqueI256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_i256(ReducerContext ctx, I256 n, int data) { @@ -1248,6 +1668,12 @@ public static void insert_unique_bool(ReducerContext ctx, bool b, int data) ctx.Db.unique_bool.Insert(new UniqueBool { b = b, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_bool(ReducerContext ctx, bool b, int data) + { + ctx.Db.unique_bool.Delete(new UniqueBool { b = b, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_bool(ReducerContext ctx, bool b, int data) { @@ -1275,6 +1701,12 @@ public static void insert_unique_string(ReducerContext ctx, string s, int data) ctx.Db.unique_string.Insert(new UniqueString { s = s, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_string(ReducerContext ctx, string s, int data) + { + ctx.Db.unique_string.Delete(new UniqueString { s = s, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_string(ReducerContext ctx, string s, int data) { @@ -1302,6 +1734,12 @@ public static void insert_unique_identity(ReducerContext ctx, Identity i, int da ctx.Db.unique_identity.Insert(new UniqueIdentity { i = i, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_identity(ReducerContext ctx, Identity i, int data) + { + ctx.Db.unique_identity.Delete(new UniqueIdentity { i = i, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_identity(ReducerContext ctx, Identity i, int data) { @@ -1329,6 +1767,12 @@ public static void insert_unique_connection_id(ReducerContext ctx, ConnectionId ctx.Db.unique_connection_id.Insert(new UniqueConnectionId { a = a, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_connection_id(ReducerContext ctx, ConnectionId a, int data) + { + ctx.Db.unique_connection_id.Delete(new UniqueConnectionId { a = a, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_connection_id(ReducerContext ctx, ConnectionId a, int data) { @@ -1356,6 +1800,12 @@ public static void insert_unique_uuid(ReducerContext ctx, Uuid u, int data) ctx.Db.unique_uuid.Insert(new UniqueUuid { u = u, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_unique_uuid(ReducerContext ctx, Uuid u, int data) + { + ctx.Db.unique_uuid.Delete(new UniqueUuid { u = u, data = data }); + } + [SpacetimeDB.Reducer] public static void update_unique_uuid(ReducerContext ctx, Uuid u, int data) { @@ -1369,6 +1819,567 @@ public static void delete_unique_uuid(ReducerContext ctx, Uuid u) ctx.Db.unique_uuid.u.Delete(u); } + [SpacetimeDB.Table(Accessor = "unique_option_u8", Public = true)] + public partial struct UniqueOptionU8 + { + [SpacetimeDB.Unique] + public byte? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.Insert(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.Delete(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u8(ReducerContext ctx, byte? n, int data) + { + ctx.Db.unique_option_u8.n.Delete(n); + ctx.Db.unique_option_u8.Insert(new UniqueOptionU8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u8(ReducerContext ctx, byte? n) + { + ctx.Db.unique_option_u8.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u16", Public = true)] + public partial struct UniqueOptionU16 + { + [SpacetimeDB.Unique] + public ushort? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.Insert(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.Delete(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u16(ReducerContext ctx, ushort? n, int data) + { + ctx.Db.unique_option_u16.n.Delete(n); + ctx.Db.unique_option_u16.Insert(new UniqueOptionU16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u16(ReducerContext ctx, ushort? n) + { + ctx.Db.unique_option_u16.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u32", Public = true)] + public partial struct UniqueOptionU32 + { + [SpacetimeDB.Unique] + public uint? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.Insert(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.Delete(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u32(ReducerContext ctx, uint? n, int data) + { + ctx.Db.unique_option_u32.n.Delete(n); + ctx.Db.unique_option_u32.Insert(new UniqueOptionU32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u32(ReducerContext ctx, uint? n) + { + ctx.Db.unique_option_u32.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u64", Public = true)] + public partial struct UniqueOptionU64 + { + [SpacetimeDB.Unique] + public ulong? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.Insert(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.Delete(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u64(ReducerContext ctx, ulong? n, int data) + { + ctx.Db.unique_option_u64.n.Delete(n); + ctx.Db.unique_option_u64.Insert(new UniqueOptionU64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u64(ReducerContext ctx, ulong? n) + { + ctx.Db.unique_option_u64.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u128", Public = true)] + public partial struct UniqueOptionU128 + { + [SpacetimeDB.Unique] + public U128? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.Insert(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.Delete(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u128(ReducerContext ctx, U128? n, int data) + { + ctx.Db.unique_option_u128.n.Delete(n); + ctx.Db.unique_option_u128.Insert(new UniqueOptionU128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u128(ReducerContext ctx, U128? n) + { + ctx.Db.unique_option_u128.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_u256", Public = true)] + public partial struct UniqueOptionU256 + { + [SpacetimeDB.Unique] + public U256? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.Insert(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.Delete(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_u256(ReducerContext ctx, U256? n, int data) + { + ctx.Db.unique_option_u256.n.Delete(n); + ctx.Db.unique_option_u256.Insert(new UniqueOptionU256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_u256(ReducerContext ctx, U256? n) + { + ctx.Db.unique_option_u256.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i8", Public = true)] + public partial struct UniqueOptionI8 + { + [SpacetimeDB.Unique] + public sbyte? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.Insert(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.Delete(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i8(ReducerContext ctx, sbyte? n, int data) + { + ctx.Db.unique_option_i8.n.Delete(n); + ctx.Db.unique_option_i8.Insert(new UniqueOptionI8 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i8(ReducerContext ctx, sbyte? n) + { + ctx.Db.unique_option_i8.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i16", Public = true)] + public partial struct UniqueOptionI16 + { + [SpacetimeDB.Unique] + public short? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.Insert(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.Delete(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i16(ReducerContext ctx, short? n, int data) + { + ctx.Db.unique_option_i16.n.Delete(n); + ctx.Db.unique_option_i16.Insert(new UniqueOptionI16 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i16(ReducerContext ctx, short? n) + { + ctx.Db.unique_option_i16.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i32", Public = true)] + public partial struct UniqueOptionI32 + { + [SpacetimeDB.Unique] + public int? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.Insert(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.Delete(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i32(ReducerContext ctx, int? n, int data) + { + ctx.Db.unique_option_i32.n.Delete(n); + ctx.Db.unique_option_i32.Insert(new UniqueOptionI32 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i32(ReducerContext ctx, int? n) + { + ctx.Db.unique_option_i32.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i64", Public = true)] + public partial struct UniqueOptionI64 + { + [SpacetimeDB.Unique] + public long? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.Insert(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.Delete(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i64(ReducerContext ctx, long? n, int data) + { + ctx.Db.unique_option_i64.n.Delete(n); + ctx.Db.unique_option_i64.Insert(new UniqueOptionI64 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i64(ReducerContext ctx, long? n) + { + ctx.Db.unique_option_i64.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i128", Public = true)] + public partial struct UniqueOptionI128 + { + [SpacetimeDB.Unique] + public I128? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.Insert(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.Delete(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i128(ReducerContext ctx, I128? n, int data) + { + ctx.Db.unique_option_i128.n.Delete(n); + ctx.Db.unique_option_i128.Insert(new UniqueOptionI128 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i128(ReducerContext ctx, I128? n) + { + ctx.Db.unique_option_i128.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_i256", Public = true)] + public partial struct UniqueOptionI256 + { + [SpacetimeDB.Unique] + public I256? n; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.Insert(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.Delete(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_i256(ReducerContext ctx, I256? n, int data) + { + ctx.Db.unique_option_i256.n.Delete(n); + ctx.Db.unique_option_i256.Insert(new UniqueOptionI256 { n = n, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_i256(ReducerContext ctx, I256? n) + { + ctx.Db.unique_option_i256.n.Delete(n); + } + + [SpacetimeDB.Table(Accessor = "unique_option_bool", Public = true)] + public partial struct UniqueOptionBool + { + [SpacetimeDB.Unique] + public bool? b; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.Insert(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.Delete(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_bool(ReducerContext ctx, bool? b, int data) + { + ctx.Db.unique_option_bool.b.Delete(b); + ctx.Db.unique_option_bool.Insert(new UniqueOptionBool { b = b, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_bool(ReducerContext ctx, bool? b) + { + ctx.Db.unique_option_bool.b.Delete(b); + } + + [SpacetimeDB.Table(Accessor = "unique_option_string", Public = true)] + public partial struct UniqueOptionString + { + [SpacetimeDB.Unique] + public string? s; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.Insert(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.Delete(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_string(ReducerContext ctx, string? s, int data) + { + ctx.Db.unique_option_string.s.Delete(s); + ctx.Db.unique_option_string.Insert(new UniqueOptionString { s = s, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_string(ReducerContext ctx, string? s) + { + ctx.Db.unique_option_string.s.Delete(s); + } + + [SpacetimeDB.Table(Accessor = "unique_option_identity", Public = true)] + public partial struct UniqueOptionIdentity + { + [SpacetimeDB.Unique] + public Identity? i; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.Insert(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.Delete(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_identity(ReducerContext ctx, Identity? i, int data) + { + ctx.Db.unique_option_identity.i.Delete(i); + ctx.Db.unique_option_identity.Insert(new UniqueOptionIdentity { i = i, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_identity(ReducerContext ctx, Identity? i) + { + ctx.Db.unique_option_identity.i.Delete(i); + } + + [SpacetimeDB.Table(Accessor = "unique_option_connection_id", Public = true)] + public partial struct UniqueOptionConnectionId + { + [SpacetimeDB.Unique] + public ConnectionId? a; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.Insert(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.Delete(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_connection_id(ReducerContext ctx, ConnectionId? a, int data) + { + ctx.Db.unique_option_connection_id.a.Delete(a); + ctx.Db.unique_option_connection_id.Insert(new UniqueOptionConnectionId { a = a, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_connection_id(ReducerContext ctx, ConnectionId? a) + { + ctx.Db.unique_option_connection_id.a.Delete(a); + } + + [SpacetimeDB.Table(Accessor = "unique_option_uuid", Public = true)] + public partial struct UniqueOptionUuid + { + [SpacetimeDB.Unique] + public Uuid? u; + public int data; + } + + [SpacetimeDB.Reducer] + public static void insert_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.Insert(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_all_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.Delete(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void update_unique_option_uuid(ReducerContext ctx, Uuid? u, int data) + { + ctx.Db.unique_option_uuid.u.Delete(u); + ctx.Db.unique_option_uuid.Insert(new UniqueOptionUuid { u = u, data = data }); + } + + [SpacetimeDB.Reducer] + public static void delete_unique_option_uuid(ReducerContext ctx, Uuid? u) + { + ctx.Db.unique_option_uuid.u.Delete(u); + } + [SpacetimeDB.Table(Accessor = "pk_u8", Public = true)] public partial struct PkU8 { @@ -1383,6 +2394,12 @@ public static void insert_pk_u8(ReducerContext ctx, byte n, int data) ctx.Db.pk_u8.Insert(new PkU8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u8(ReducerContext ctx, byte n, int data) + { + ctx.Db.pk_u8.Delete(new PkU8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u8(ReducerContext ctx, byte n, int data) { @@ -1410,6 +2427,12 @@ public static void insert_pk_u16(ReducerContext ctx, ushort n, int data) ctx.Db.pk_u16.Insert(new PkU16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u16(ReducerContext ctx, ushort n, int data) + { + ctx.Db.pk_u16.Delete(new PkU16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u16(ReducerContext ctx, ushort n, int data) { @@ -1437,6 +2460,12 @@ public static void insert_pk_u32(ReducerContext ctx, uint n, int data) ctx.Db.pk_u32.Insert(new PkU32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u32(ReducerContext ctx, uint n, int data) + { + ctx.Db.pk_u32.Delete(new PkU32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u32(ReducerContext ctx, uint n, int data) { @@ -1471,6 +2500,12 @@ public static void insert_pk_u32_two(ReducerContext ctx, uint n, int data) ctx.Db.pk_u32_two.Insert(new PkU32Two { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u32_two(ReducerContext ctx, uint n, int data) + { + ctx.Db.pk_u32_two.Delete(new PkU32Two { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u32_two(ReducerContext ctx, uint n, int data) { @@ -1498,6 +2533,12 @@ public static void insert_pk_u64(ReducerContext ctx, ulong n, int data) ctx.Db.pk_u64.Insert(new PkU64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u64(ReducerContext ctx, ulong n, int data) + { + ctx.Db.pk_u64.Delete(new PkU64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u64(ReducerContext ctx, ulong n, int data) { @@ -1525,6 +2566,12 @@ public static void insert_pk_u128(ReducerContext ctx, U128 n, int data) ctx.Db.pk_u128.Insert(new PkU128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u128(ReducerContext ctx, U128 n, int data) + { + ctx.Db.pk_u128.Delete(new PkU128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u128(ReducerContext ctx, U128 n, int data) { @@ -1552,6 +2599,12 @@ public static void insert_pk_u256(ReducerContext ctx, U256 n, int data) ctx.Db.pk_u256.Insert(new PkU256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_u256(ReducerContext ctx, U256 n, int data) + { + ctx.Db.pk_u256.Delete(new PkU256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_u256(ReducerContext ctx, U256 n, int data) { @@ -1579,6 +2632,12 @@ public static void insert_pk_i8(ReducerContext ctx, sbyte n, int data) ctx.Db.pk_i8.Insert(new PkI8 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i8(ReducerContext ctx, sbyte n, int data) + { + ctx.Db.pk_i8.Delete(new PkI8 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i8(ReducerContext ctx, sbyte n, int data) { @@ -1606,6 +2665,12 @@ public static void insert_pk_i16(ReducerContext ctx, short n, int data) ctx.Db.pk_i16.Insert(new PkI16 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i16(ReducerContext ctx, short n, int data) + { + ctx.Db.pk_i16.Delete(new PkI16 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i16(ReducerContext ctx, short n, int data) { @@ -1633,6 +2698,12 @@ public static void insert_pk_i32(ReducerContext ctx, int n, int data) ctx.Db.pk_i32.Insert(new PkI32 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i32(ReducerContext ctx, int n, int data) + { + ctx.Db.pk_i32.Delete(new PkI32 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i32(ReducerContext ctx, int n, int data) { @@ -1660,6 +2731,12 @@ public static void insert_pk_i64(ReducerContext ctx, long n, int data) ctx.Db.pk_i64.Insert(new PkI64 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i64(ReducerContext ctx, long n, int data) + { + ctx.Db.pk_i64.Delete(new PkI64 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i64(ReducerContext ctx, long n, int data) { @@ -1687,6 +2764,12 @@ public static void insert_pk_i128(ReducerContext ctx, I128 n, int data) ctx.Db.pk_i128.Insert(new PkI128 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i128(ReducerContext ctx, I128 n, int data) + { + ctx.Db.pk_i128.Delete(new PkI128 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i128(ReducerContext ctx, I128 n, int data) { @@ -1714,6 +2797,12 @@ public static void insert_pk_i256(ReducerContext ctx, I256 n, int data) ctx.Db.pk_i256.Insert(new PkI256 { n = n, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_i256(ReducerContext ctx, I256 n, int data) + { + ctx.Db.pk_i256.Delete(new PkI256 { n = n, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_i256(ReducerContext ctx, I256 n, int data) { @@ -1741,6 +2830,12 @@ public static void insert_pk_bool(ReducerContext ctx, bool b, int data) ctx.Db.pk_bool.Insert(new PkBool { b = b, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_bool(ReducerContext ctx, bool b, int data) + { + ctx.Db.pk_bool.Delete(new PkBool { b = b, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_bool(ReducerContext ctx, bool b, int data) { @@ -1768,6 +2863,12 @@ public static void insert_pk_string(ReducerContext ctx, string s, int data) ctx.Db.pk_string.Insert(new PkString { s = s, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_string(ReducerContext ctx, string s, int data) + { + ctx.Db.pk_string.Delete(new PkString { s = s, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_string(ReducerContext ctx, string s, int data) { @@ -1795,6 +2896,12 @@ public static void insert_pk_identity(ReducerContext ctx, Identity i, int data) ctx.Db.pk_identity.Insert(new PkIdentity { i = i, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_identity(ReducerContext ctx, Identity i, int data) + { + ctx.Db.pk_identity.Delete(new PkIdentity { i = i, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_identity(ReducerContext ctx, Identity i, int data) { @@ -1822,6 +2929,12 @@ public static void insert_pk_connection_id(ReducerContext ctx, ConnectionId a, i ctx.Db.pk_connection_id.Insert(new PkConnectionId { a = a, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_connection_id(ReducerContext ctx, ConnectionId a, int data) + { + ctx.Db.pk_connection_id.Delete(new PkConnectionId { a = a, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_connection_id(ReducerContext ctx, ConnectionId a, int data) { @@ -1849,6 +2962,12 @@ public static void insert_pk_uuid(ReducerContext ctx, Uuid u, int data) ctx.Db.pk_uuid.Insert(new PkUuid { u = u, data = data }); } + [SpacetimeDB.Reducer] + public static void delete_all_pk_uuid(ReducerContext ctx, Uuid u, int data) + { + ctx.Db.pk_uuid.Delete(new PkUuid { u = u, data = data }); + } + [SpacetimeDB.Reducer] public static void update_pk_uuid(ReducerContext ctx, Uuid u, int data) { diff --git a/modules/sdk-test-ts/src/index.ts b/modules/sdk-test-ts/src/index.ts index 257086782f0..78dc28c9290 100644 --- a/modules/sdk-test-ts/src/index.ts +++ b/modules/sdk-test-ts/src/index.ts @@ -112,13 +112,17 @@ function tbl( ops: { insert?: string; delete?: string; + delete_all?: string; insert_or_panic?: string; update_by?: [string, keyof Row]; update_non_pk_by?: [string, keyof Row]; delete_by?: [string, keyof Row]; }, row: Row -): TableWithReducers>> { +): TableWithReducers< + Accessor, + ReturnType> +> { const t = table({ public: true }, row); return { table: t, @@ -134,6 +138,11 @@ function tbl( (ctx.db[accessor] as any).delete({ ...args }); }); } + if (ops.delete_all) { + exports[ops.delete_all] = spacetimedb.reducer(row, (ctx, args) => { + (ctx.db[accessor] as any).delete({ ...args }); + }); + } if (ops.insert_or_panic) { exports[ops.insert_or_panic] = spacetimedb.reducer(row, (ctx, args) => { (ctx.db[accessor] as any).insert({ ...args }); @@ -168,34 +177,94 @@ function tbl( // Tables holding a single value. const singleValTables = { - oneU8: tbl('oneU8', { insert: 'insert_one_u8' }, { n: t.u8() }), - oneU16: tbl('oneU16', { insert: 'insert_one_u16' }, { n: t.u16() }), - oneU32: tbl('oneU32', { insert: 'insert_one_u32' }, { n: t.u32() }), - oneU64: tbl('oneU64', { insert: 'insert_one_u64' }, { n: t.u64() }), - oneU128: tbl('oneU128', { insert: 'insert_one_u128' }, { n: t.u128() }), - oneU256: tbl('oneU256', { insert: 'insert_one_u256' }, { n: t.u256() }), + oneU8: tbl( + 'oneU8', + { insert: 'insert_one_u8', delete_all: 'delete_all_one_u8' }, + { n: t.u8() } + ), + oneU16: tbl( + 'oneU16', + { insert: 'insert_one_u16', delete_all: 'delete_all_one_u16' }, + { n: t.u16() } + ), + oneU32: tbl( + 'oneU32', + { insert: 'insert_one_u32', delete_all: 'delete_all_one_u32' }, + { n: t.u32() } + ), + oneU64: tbl( + 'oneU64', + { insert: 'insert_one_u64', delete_all: 'delete_all_one_u64' }, + { n: t.u64() } + ), + oneU128: tbl( + 'oneU128', + { insert: 'insert_one_u128', delete_all: 'delete_all_one_u128' }, + { n: t.u128() } + ), + oneU256: tbl( + 'oneU256', + { insert: 'insert_one_u256', delete_all: 'delete_all_one_u256' }, + { n: t.u256() } + ), - oneI8: tbl('oneI8', { insert: 'insert_one_i8' }, { n: t.i8() }), - oneI16: tbl('oneI16', { insert: 'insert_one_i16' }, { n: t.i16() }), - oneI32: tbl('oneI32', { insert: 'insert_one_i32' }, { n: t.i32() }), - oneI64: tbl('oneI64', { insert: 'insert_one_i64' }, { n: t.i64() }), - oneI128: tbl('oneI128', { insert: 'insert_one_i128' }, { n: t.i128() }), - oneI256: tbl('oneI256', { insert: 'insert_one_i256' }, { n: t.i256() }), + oneI8: tbl( + 'oneI8', + { insert: 'insert_one_i8', delete_all: 'delete_all_one_i8' }, + { n: t.i8() } + ), + oneI16: tbl( + 'oneI16', + { insert: 'insert_one_i16', delete_all: 'delete_all_one_i16' }, + { n: t.i16() } + ), + oneI32: tbl( + 'oneI32', + { insert: 'insert_one_i32', delete_all: 'delete_all_one_i32' }, + { n: t.i32() } + ), + oneI64: tbl( + 'oneI64', + { insert: 'insert_one_i64', delete_all: 'delete_all_one_i64' }, + { n: t.i64() } + ), + oneI128: tbl( + 'oneI128', + { insert: 'insert_one_i128', delete_all: 'delete_all_one_i128' }, + { n: t.i128() } + ), + oneI256: tbl( + 'oneI256', + { insert: 'insert_one_i256', delete_all: 'delete_all_one_i256' }, + { n: t.i256() } + ), - oneBool: tbl('oneBool', { insert: 'insert_one_bool' }, { b: t.bool() }), + oneBool: tbl( + 'oneBool', + { insert: 'insert_one_bool', delete_all: 'delete_all_one_bool' }, + { b: t.bool() } + ), - oneF32: tbl('oneF32', { insert: 'insert_one_f32' }, { f: t.f32() }), - oneF64: tbl('oneF64', { insert: 'insert_one_f64' }, { f: t.f64() }), + oneF32: tbl( + 'oneF32', + { insert: 'insert_one_f32', delete_all: 'delete_all_one_f32' }, + { f: t.f32() } + ), + oneF64: tbl( + 'oneF64', + { insert: 'insert_one_f64', delete_all: 'delete_all_one_f64' }, + { f: t.f64() } + ), oneString: tbl( 'oneString', - { insert: 'insert_one_string' }, + { insert: 'insert_one_string', delete_all: 'delete_all_one_string' }, { s: t.string() } ), oneIdentity: tbl( 'oneIdentity', - { insert: 'insert_one_identity' }, + { insert: 'insert_one_identity', delete_all: 'delete_all_one_identity' }, { i: t.identity() } ), oneConnectionId: tbl( @@ -204,129 +273,159 @@ const singleValTables = { { a: t.connectionId() } ), - oneUuid: tbl('oneUuid', { insert: 'insert_one_uuid' }, { u: t.uuid() }), + oneUuid: tbl( + 'oneUuid', + { insert: 'insert_one_uuid', delete_all: 'delete_all_one_uuid' }, + { u: t.uuid() } + ), oneTimestamp: tbl( 'oneTimestamp', - { insert: 'insert_one_timestamp' }, + { insert: 'insert_one_timestamp', delete_all: 'delete_all_one_timestamp' }, { t: t.timestamp() } ), oneSimpleEnum: tbl( 'oneSimpleEnum', - { insert: 'insert_one_simple_enum' }, + { + insert: 'insert_one_simple_enum', + delete_all: 'delete_all_one_simple_enum', + }, { e: SimpleEnum } ), oneEnumWithPayload: tbl( 'oneEnumWithPayload', - { insert: 'insert_one_enum_with_payload' }, + { + insert: 'insert_one_enum_with_payload', + delete_all: 'delete_all_one_enum_with_payload', + }, { e: EnumWithPayload } ), oneUnitStruct: tbl( 'oneUnitStruct', - { insert: 'insert_one_unit_struct' }, + { + insert: 'insert_one_unit_struct', + delete_all: 'delete_all_one_unit_struct', + }, { s: UnitStruct } ), oneByteStruct: tbl( 'oneByteStruct', - { insert: 'insert_one_byte_struct' }, + { + insert: 'insert_one_byte_struct', + delete_all: 'delete_all_one_byte_struct', + }, { s: ByteStruct } ), oneEveryPrimitiveStruct: tbl( 'oneEveryPrimitiveStruct', - { insert: 'insert_one_every_primitive_struct' }, + { + insert: 'insert_one_every_primitive_struct', + delete_all: 'delete_all_one_every_primitive_struct', + }, { s: EveryPrimitiveStruct } ), oneEveryVecStruct: tbl( 'oneEveryVecStruct', - { insert: 'insert_one_every_vec_struct' }, + { + insert: 'insert_one_every_vec_struct', + delete_all: 'delete_all_one_every_vec_struct', + }, { s: EveryVecStruct } ), } as const; // Tables holding a Vec of various types. const vecTables = { - vecU8: tbl('vecU8', { insert: 'insert_vec_u8' }, { n: t.array(t.u8()) }), + vecU8: tbl( + 'vecU8', + { insert: 'insert_vec_u8', delete_all: 'delete_all_vec_u8' }, + { n: t.array(t.u8()) } + ), vecU16: tbl( 'vecU16', - { insert: 'insert_vec_u16' }, + { insert: 'insert_vec_u16', delete_all: 'delete_all_vec_u16' }, { n: t.array(t.u16()) } ), vecU32: tbl( 'vecU32', - { insert: 'insert_vec_u32' }, + { insert: 'insert_vec_u32', delete_all: 'delete_all_vec_u32' }, { n: t.array(t.u32()) } ), vecU64: tbl( 'vecU64', - { insert: 'insert_vec_u64' }, + { insert: 'insert_vec_u64', delete_all: 'delete_all_vec_u64' }, { n: t.array(t.u64()) } ), vecU128: tbl( 'vecU128', - { insert: 'insert_vec_u128' }, + { insert: 'insert_vec_u128', delete_all: 'delete_all_vec_u128' }, { n: t.array(t.u128()) } ), vecU256: tbl( 'vecU256', - { insert: 'insert_vec_u256' }, + { insert: 'insert_vec_u256', delete_all: 'delete_all_vec_u256' }, { n: t.array(t.u256()) } ), - vecI8: tbl('vecI8', { insert: 'insert_vec_i8' }, { n: t.array(t.i8()) }), + vecI8: tbl( + 'vecI8', + { insert: 'insert_vec_i8', delete_all: 'delete_all_vec_i8' }, + { n: t.array(t.i8()) } + ), vecI16: tbl( 'vecI16', - { insert: 'insert_vec_i16' }, + { insert: 'insert_vec_i16', delete_all: 'delete_all_vec_i16' }, { n: t.array(t.i16()) } ), vecI32: tbl( 'vecI32', - { insert: 'insert_vec_i32' }, + { insert: 'insert_vec_i32', delete_all: 'delete_all_vec_i32' }, { n: t.array(t.i32()) } ), vecI64: tbl( 'vecI64', - { insert: 'insert_vec_i64' }, + { insert: 'insert_vec_i64', delete_all: 'delete_all_vec_i64' }, { n: t.array(t.i64()) } ), vecI128: tbl( 'vecI128', - { insert: 'insert_vec_i128' }, + { insert: 'insert_vec_i128', delete_all: 'delete_all_vec_i128' }, { n: t.array(t.i128()) } ), vecI256: tbl( 'vecI256', - { insert: 'insert_vec_i256' }, + { insert: 'insert_vec_i256', delete_all: 'delete_all_vec_i256' }, { n: t.array(t.i256()) } ), vecBool: tbl( 'vecBool', - { insert: 'insert_vec_bool' }, + { insert: 'insert_vec_bool', delete_all: 'delete_all_vec_bool' }, { b: t.array(t.bool()) } ), vecF32: tbl( 'vecF32', - { insert: 'insert_vec_f32' }, + { insert: 'insert_vec_f32', delete_all: 'delete_all_vec_f32' }, { f: t.array(t.f32()) } ), vecF64: tbl( 'vecF64', - { insert: 'insert_vec_f64' }, + { insert: 'insert_vec_f64', delete_all: 'delete_all_vec_f64' }, { f: t.array(t.f64()) } ), vecString: tbl( 'vecString', - { insert: 'insert_vec_string' }, + { insert: 'insert_vec_string', delete_all: 'delete_all_vec_string' }, { s: t.array(t.string()) } ), vecIdentity: tbl( 'vecIdentity', - { insert: 'insert_vec_identity' }, + { insert: 'insert_vec_identity', delete_all: 'delete_all_vec_identity' }, { i: t.array(t.identity()) } ), vecConnectionId: tbl( @@ -337,45 +436,63 @@ const vecTables = { vecTimestamp: tbl( 'vecTimestamp', - { insert: 'insert_vec_timestamp' }, + { insert: 'insert_vec_timestamp', delete_all: 'delete_all_vec_timestamp' }, { t: t.array(t.timestamp()) } ), vecUuid: tbl( 'vecUuid', - { insert: 'insert_vec_uuid' }, + { insert: 'insert_vec_uuid', delete_all: 'delete_all_vec_uuid' }, { u: t.array(t.uuid()) } ), vecSimpleEnum: tbl( 'vecSimpleEnum', - { insert: 'insert_vec_simple_enum' }, + { + insert: 'insert_vec_simple_enum', + delete_all: 'delete_all_vec_simple_enum', + }, { e: t.array(SimpleEnum) } ), vecEnumWithPayload: tbl( 'vecEnumWithPayload', - { insert: 'insert_vec_enum_with_payload' }, + { + insert: 'insert_vec_enum_with_payload', + delete_all: 'delete_all_vec_enum_with_payload', + }, { e: t.array(EnumWithPayload) } ), vecUnitStruct: tbl( 'vecUnitStruct', - { insert: 'insert_vec_unit_struct' }, + { + insert: 'insert_vec_unit_struct', + delete_all: 'delete_all_vec_unit_struct', + }, { s: t.array(UnitStruct) } ), vecByteStruct: tbl( 'vecByteStruct', - { insert: 'insert_vec_byte_struct' }, + { + insert: 'insert_vec_byte_struct', + delete_all: 'delete_all_vec_byte_struct', + }, { s: t.array(ByteStruct) } ), vecEveryPrimitiveStruct: tbl( 'vecEveryPrimitiveStruct', - { insert: 'insert_vec_every_primitive_struct' }, + { + insert: 'insert_vec_every_primitive_struct', + delete_all: 'delete_all_vec_every_primitive_struct', + }, { s: t.array(EveryPrimitiveStruct) } ), vecEveryVecStruct: tbl( 'vecEveryVecStruct', - { insert: 'insert_vec_every_vec_struct' }, + { + insert: 'insert_vec_every_vec_struct', + delete_all: 'delete_all_vec_every_vec_struct', + }, { s: t.array(EveryVecStruct) } ), } as const; @@ -384,37 +501,49 @@ const vecTables = { const optionTables = { optionI32: tbl( 'optionI32', - { insert: 'insert_option_i32' }, + { insert: 'insert_option_i32', delete_all: 'delete_all_option_i32' }, { n: t.option(t.i32()) } ), optionString: tbl( 'optionString', - { insert: 'insert_option_string' }, + { insert: 'insert_option_string', delete_all: 'delete_all_option_string' }, { s: t.option(t.string()) } ), optionIdentity: tbl( 'optionIdentity', - { insert: 'insert_option_identity' }, + { + insert: 'insert_option_identity', + delete_all: 'delete_all_option_identity', + }, { i: t.option(t.identity()) } ), optionUuid: tbl( 'optionUuid', - { insert: 'insert_option_uuid' }, + { insert: 'insert_option_uuid', delete_all: 'delete_all_option_uuid' }, { u: t.option(t.uuid()) } ), optionSimpleEnum: tbl( 'optionSimpleEnum', - { insert: 'insert_option_simple_enum' }, + { + insert: 'insert_option_simple_enum', + delete_all: 'delete_all_option_simple_enum', + }, { e: t.option(SimpleEnum) } ), optionEveryPrimitiveStruct: tbl( 'optionEveryPrimitiveStruct', - { insert: 'insert_option_every_primitive_struct' }, + { + insert: 'insert_option_every_primitive_struct', + delete_all: 'delete_all_option_every_primitive_struct', + }, { s: t.option(EveryPrimitiveStruct) } ), optionVecOptionI32: tbl( 'optionVecOptionI32', - { insert: 'insert_option_vec_option_i32' }, + { + insert: 'insert_option_vec_option_i32', + delete_all: 'delete_all_option_vec_option_i32', + }, { v: t.option(t.array(t.option(t.i32()))) } ), } as const; @@ -460,6 +589,8 @@ const uniqueTables = { 'uniqueU8', { insert_or_panic: 'insert_unique_u8', + + delete_all: 'delete_all_unique_u8', update_non_pk_by: ['update_unique_u8', 'n'], delete_by: ['delete_unique_u8', 'n'], }, @@ -470,6 +601,8 @@ const uniqueTables = { 'uniqueU16', { insert_or_panic: 'insert_unique_u16', + + delete_all: 'delete_all_unique_u16', update_non_pk_by: ['update_unique_u16', 'n'], delete_by: ['delete_unique_u16', 'n'], }, @@ -480,6 +613,8 @@ const uniqueTables = { 'uniqueU32', { insert_or_panic: 'insert_unique_u32', + + delete_all: 'delete_all_unique_u32', update_non_pk_by: ['update_unique_u32', 'n'], delete_by: ['delete_unique_u32', 'n'], }, @@ -490,6 +625,8 @@ const uniqueTables = { 'uniqueU64', { insert_or_panic: 'insert_unique_u64', + + delete_all: 'delete_all_unique_u64', update_non_pk_by: ['update_unique_u64', 'n'], delete_by: ['delete_unique_u64', 'n'], }, @@ -500,6 +637,8 @@ const uniqueTables = { 'uniqueU128', { insert_or_panic: 'insert_unique_u128', + + delete_all: 'delete_all_unique_u128', update_non_pk_by: ['update_unique_u128', 'n'], delete_by: ['delete_unique_u128', 'n'], }, @@ -510,6 +649,8 @@ const uniqueTables = { 'uniqueU256', { insert_or_panic: 'insert_unique_u256', + + delete_all: 'delete_all_unique_u256', update_non_pk_by: ['update_unique_u256', 'n'], delete_by: ['delete_unique_u256', 'n'], }, @@ -520,6 +661,8 @@ const uniqueTables = { 'uniqueI8', { insert_or_panic: 'insert_unique_i8', + + delete_all: 'delete_all_unique_i8', update_non_pk_by: ['update_unique_i8', 'n'], delete_by: ['delete_unique_i8', 'n'], }, @@ -530,6 +673,8 @@ const uniqueTables = { 'uniqueI16', { insert_or_panic: 'insert_unique_i16', + + delete_all: 'delete_all_unique_i16', update_non_pk_by: ['update_unique_i16', 'n'], delete_by: ['delete_unique_i16', 'n'], }, @@ -540,6 +685,8 @@ const uniqueTables = { 'uniqueI32', { insert_or_panic: 'insert_unique_i32', + + delete_all: 'delete_all_unique_i32', update_non_pk_by: ['update_unique_i32', 'n'], delete_by: ['delete_unique_i32', 'n'], }, @@ -550,6 +697,8 @@ const uniqueTables = { 'uniqueI64', { insert_or_panic: 'insert_unique_i64', + + delete_all: 'delete_all_unique_i64', update_non_pk_by: ['update_unique_i64', 'n'], delete_by: ['delete_unique_i64', 'n'], }, @@ -560,6 +709,8 @@ const uniqueTables = { 'uniqueI128', { insert_or_panic: 'insert_unique_i128', + + delete_all: 'delete_all_unique_i128', update_non_pk_by: ['update_unique_i128', 'n'], delete_by: ['delete_unique_i128', 'n'], }, @@ -570,6 +721,8 @@ const uniqueTables = { 'uniqueI256', { insert_or_panic: 'insert_unique_i256', + + delete_all: 'delete_all_unique_i256', update_non_pk_by: ['update_unique_i256', 'n'], delete_by: ['delete_unique_i256', 'n'], }, @@ -580,6 +733,8 @@ const uniqueTables = { 'uniqueBool', { insert_or_panic: 'insert_unique_bool', + + delete_all: 'delete_all_unique_bool', update_non_pk_by: ['update_unique_bool', 'b'], delete_by: ['delete_unique_bool', 'b'], }, @@ -590,6 +745,8 @@ const uniqueTables = { 'uniqueString', { insert_or_panic: 'insert_unique_string', + + delete_all: 'delete_all_unique_string', update_non_pk_by: ['update_unique_string', 's'], delete_by: ['delete_unique_string', 's'], }, @@ -600,6 +757,8 @@ const uniqueTables = { 'uniqueIdentity', { insert_or_panic: 'insert_unique_identity', + + delete_all: 'delete_all_unique_identity', update_non_pk_by: ['update_unique_identity', 'i'], delete_by: ['delete_unique_identity', 'i'], }, @@ -610,6 +769,8 @@ const uniqueTables = { 'uniqueConnectionId', { insert_or_panic: 'insert_unique_connection_id', + + delete_all: 'delete_all_unique_connection_id', update_non_pk_by: ['update_unique_connection_id', 'a'], delete_by: ['delete_unique_connection_id', 'a'], }, @@ -620,6 +781,8 @@ const uniqueTables = { 'uniqueUuid', { insert_or_panic: 'insert_unique_uuid', + + delete_all: 'delete_all_unique_uuid', update_non_pk_by: ['update_unique_uuid', 'u'], delete_by: ['delete_unique_uuid', 'u'], }, @@ -627,6 +790,197 @@ const uniqueTables = { ), } as const; +// Tables mapping a unique Option for some T to a boring i32 payload. +const uniqueOptionTables = { + uniqueOptionU8: tbl( + 'uniqueOptionU8', + { + insert_or_panic: 'insert_unique_option_u8', + + delete_all: 'delete_all_unique_option_u8', + update_non_pk_by: ['update_unique_option_u8', 'n'], + delete_by: ['delete_unique_option_u8', 'n'], + }, + { n: t.option(t.u8()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU16: tbl( + 'uniqueOptionU16', + { + insert_or_panic: 'insert_unique_option_u16', + + delete_all: 'delete_all_unique_option_u16', + update_non_pk_by: ['update_unique_option_u16', 'n'], + delete_by: ['delete_unique_option_u16', 'n'], + }, + { n: t.option(t.u16()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU32: tbl( + 'uniqueOptionU32', + { + insert_or_panic: 'insert_unique_option_u32', + + delete_all: 'delete_all_unique_option_u32', + update_non_pk_by: ['update_unique_option_u32', 'n'], + delete_by: ['delete_unique_option_u32', 'n'], + }, + { n: t.option(t.u32()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU64: tbl( + 'uniqueOptionU64', + { + insert_or_panic: 'insert_unique_option_u64', + + delete_all: 'delete_all_unique_option_u64', + update_non_pk_by: ['update_unique_option_u64', 'n'], + delete_by: ['delete_unique_option_u64', 'n'], + }, + { n: t.option(t.u64()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU128: tbl( + 'uniqueOptionU128', + { + insert_or_panic: 'insert_unique_option_u128', + + delete_all: 'delete_all_unique_option_u128', + update_non_pk_by: ['update_unique_option_u128', 'n'], + delete_by: ['delete_unique_option_u128', 'n'], + }, + { n: t.option(t.u128()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionU256: tbl( + 'uniqueOptionU256', + { + insert_or_panic: 'insert_unique_option_u256', + + delete_all: 'delete_all_unique_option_u256', + update_non_pk_by: ['update_unique_option_u256', 'n'], + delete_by: ['delete_unique_option_u256', 'n'], + }, + { n: t.option(t.u256()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI8: tbl( + 'uniqueOptionI8', + { + insert_or_panic: 'insert_unique_option_i8', + + delete_all: 'delete_all_unique_option_i8', + update_non_pk_by: ['update_unique_option_i8', 'n'], + delete_by: ['delete_unique_option_i8', 'n'], + }, + { n: t.option(t.i8()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI16: tbl( + 'uniqueOptionI16', + { + insert_or_panic: 'insert_unique_option_i16', + + delete_all: 'delete_all_unique_option_i16', + update_non_pk_by: ['update_unique_option_i16', 'n'], + delete_by: ['delete_unique_option_i16', 'n'], + }, + { n: t.option(t.i16()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI32: tbl( + 'uniqueOptionI32', + { + insert_or_panic: 'insert_unique_option_i32', + + delete_all: 'delete_all_unique_option_i32', + update_non_pk_by: ['update_unique_option_i32', 'n'], + delete_by: ['delete_unique_option_i32', 'n'], + }, + { n: t.option(t.i32()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI64: tbl( + 'uniqueOptionI64', + { + insert_or_panic: 'insert_unique_option_i64', + + delete_all: 'delete_all_unique_option_i64', + update_non_pk_by: ['update_unique_option_i64', 'n'], + delete_by: ['delete_unique_option_i64', 'n'], + }, + { n: t.option(t.i64()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI128: tbl( + 'uniqueOptionI128', + { + insert_or_panic: 'insert_unique_option_i128', + + delete_all: 'delete_all_unique_option_i128', + update_non_pk_by: ['update_unique_option_i128', 'n'], + delete_by: ['delete_unique_option_i128', 'n'], + }, + { n: t.option(t.i128()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionI256: tbl( + 'uniqueOptionI256', + { + insert_or_panic: 'insert_unique_option_i256', + + delete_all: 'delete_all_unique_option_i256', + update_non_pk_by: ['update_unique_option_i256', 'n'], + delete_by: ['delete_unique_option_i256', 'n'], + }, + { n: t.option(t.i256()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionBool: tbl( + 'uniqueOptionBool', + { + insert_or_panic: 'insert_unique_option_bool', + + delete_all: 'delete_all_unique_option_bool', + update_non_pk_by: ['update_unique_option_bool', 'b'], + delete_by: ['delete_unique_option_bool', 'b'], + }, + { b: t.option(t.bool()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionString: tbl( + 'uniqueOptionString', + { + insert_or_panic: 'insert_unique_option_string', + + delete_all: 'delete_all_unique_option_string', + update_non_pk_by: ['update_unique_option_string', 's'], + delete_by: ['delete_unique_option_string', 's'], + }, + { s: t.option(t.string()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionIdentity: tbl( + 'uniqueOptionIdentity', + { + insert_or_panic: 'insert_unique_option_identity', + + delete_all: 'delete_all_unique_option_identity', + update_non_pk_by: ['update_unique_option_identity', 'i'], + delete_by: ['delete_unique_option_identity', 'i'], + }, + { i: t.option(t.identity()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionConnectionId: tbl( + 'uniqueOptionConnectionId', + { + insert_or_panic: 'insert_unique_option_connection_id', + + delete_all: 'delete_all_unique_option_connection_id', + update_non_pk_by: ['update_unique_option_connection_id', 'a'], + delete_by: ['delete_unique_option_connection_id', 'a'], + }, + { a: t.option(t.connectionId()).index('btree').unique(), data: t.i32() } + ), + uniqueOptionUuid: tbl( + 'uniqueOptionUuid', + { + insert_or_panic: 'insert_unique_option_uuid', + + delete_all: 'delete_all_unique_option_uuid', + update_non_pk_by: ['update_unique_option_uuid', 'u'], + delete_by: ['delete_unique_option_uuid', 'u'], + }, + { u: t.option(t.uuid()).index('btree').unique(), data: t.i32() } + ), +} as const; + // Tables mapping a primary key to a boring i32 payload. // This allows us to test update and delete events. const pkTables = { @@ -634,6 +988,8 @@ const pkTables = { 'pkU8', { insert_or_panic: 'insert_pk_u8', + + delete_all: 'delete_all_pk_u8', update_by: ['update_pk_u8', 'n'], delete_by: ['delete_pk_u8', 'n'], }, @@ -644,6 +1000,8 @@ const pkTables = { 'pkU16', { insert_or_panic: 'insert_pk_u16', + + delete_all: 'delete_all_pk_u16', update_by: ['update_pk_u16', 'n'], delete_by: ['delete_pk_u16', 'n'], }, @@ -654,6 +1012,8 @@ const pkTables = { 'pkU32', { insert_or_panic: 'insert_pk_u32', + + delete_all: 'delete_all_pk_u32', update_by: ['update_pk_u32', 'n'], delete_by: ['delete_pk_u32', 'n'], }, @@ -664,6 +1024,8 @@ const pkTables = { 'pkU32Two', { insert_or_panic: 'insert_pk_u32_two', + + delete_all: 'delete_all_pk_u32_two', update_by: ['update_pk_u32_two', 'n'], delete_by: ['delete_pk_u32_two', 'n'], }, @@ -674,6 +1036,8 @@ const pkTables = { 'pkU64', { insert_or_panic: 'insert_pk_u64', + + delete_all: 'delete_all_pk_u64', update_by: ['update_pk_u64', 'n'], delete_by: ['delete_pk_u64', 'n'], }, @@ -684,6 +1048,8 @@ const pkTables = { 'pkU128', { insert_or_panic: 'insert_pk_u128', + + delete_all: 'delete_all_pk_u128', update_by: ['update_pk_u128', 'n'], delete_by: ['delete_pk_u128', 'n'], }, @@ -694,6 +1060,8 @@ const pkTables = { 'pkU256', { insert_or_panic: 'insert_pk_u256', + + delete_all: 'delete_all_pk_u256', update_by: ['update_pk_u256', 'n'], delete_by: ['delete_pk_u256', 'n'], }, @@ -704,6 +1072,8 @@ const pkTables = { 'pkI8', { insert_or_panic: 'insert_pk_i8', + + delete_all: 'delete_all_pk_i8', update_by: ['update_pk_i8', 'n'], delete_by: ['delete_pk_i8', 'n'], }, @@ -714,6 +1084,8 @@ const pkTables = { 'pkI16', { insert_or_panic: 'insert_pk_i16', + + delete_all: 'delete_all_pk_i16', update_by: ['update_pk_i16', 'n'], delete_by: ['delete_pk_i16', 'n'], }, @@ -724,6 +1096,8 @@ const pkTables = { 'pkI32', { insert_or_panic: 'insert_pk_i32', + + delete_all: 'delete_all_pk_i32', update_by: ['update_pk_i32', 'n'], delete_by: ['delete_pk_i32', 'n'], }, @@ -734,6 +1108,8 @@ const pkTables = { 'pkI64', { insert_or_panic: 'insert_pk_i64', + + delete_all: 'delete_all_pk_i64', update_by: ['update_pk_i64', 'n'], delete_by: ['delete_pk_i64', 'n'], }, @@ -744,6 +1120,8 @@ const pkTables = { 'pkI128', { insert_or_panic: 'insert_pk_i128', + + delete_all: 'delete_all_pk_i128', update_by: ['update_pk_i128', 'n'], delete_by: ['delete_pk_i128', 'n'], }, @@ -754,6 +1132,8 @@ const pkTables = { 'pkI256', { insert_or_panic: 'insert_pk_i256', + + delete_all: 'delete_all_pk_i256', update_by: ['update_pk_i256', 'n'], delete_by: ['delete_pk_i256', 'n'], }, @@ -764,6 +1144,8 @@ const pkTables = { 'pkBool', { insert_or_panic: 'insert_pk_bool', + + delete_all: 'delete_all_pk_bool', update_by: ['update_pk_bool', 'b'], delete_by: ['delete_pk_bool', 'b'], }, @@ -774,6 +1156,8 @@ const pkTables = { 'pkString', { insert_or_panic: 'insert_pk_string', + + delete_all: 'delete_all_pk_string', update_by: ['update_pk_string', 's'], delete_by: ['delete_pk_string', 's'], }, @@ -784,6 +1168,8 @@ const pkTables = { 'pkIdentity', { insert_or_panic: 'insert_pk_identity', + + delete_all: 'delete_all_pk_identity', update_by: ['update_pk_identity', 'i'], delete_by: ['delete_pk_identity', 'i'], }, @@ -794,6 +1180,8 @@ const pkTables = { 'pkConnectionId', { insert_or_panic: 'insert_pk_connection_id', + + delete_all: 'delete_all_pk_connection_id', update_by: ['update_pk_connection_id', 'a'], delete_by: ['delete_pk_connection_id', 'a'], }, @@ -804,6 +1192,8 @@ const pkTables = { 'pkUuid', { insert_or_panic: 'insert_pk_uuid', + + delete_all: 'delete_all_pk_uuid', update_by: ['update_pk_uuid', 'u'], delete_by: ['delete_pk_uuid', 'u'], }, @@ -876,6 +1266,7 @@ const allTables = { ...optionTables, ...resultTables, ...uniqueTables, + ...uniqueOptionTables, ...pkTables, ...weirdTables, } as const; diff --git a/sdks/csharp/examples~/regression-tests/client/Program.cs b/sdks/csharp/examples~/regression-tests/client/Program.cs index 7f947cbc9d6..8ff95550767 100644 --- a/sdks/csharp/examples~/regression-tests/client/Program.cs +++ b/sdks/csharp/examples~/regression-tests/client/Program.cs @@ -50,6 +50,7 @@ void OnConnected(DbConnection conn, Identity identity, string authToken) .AddQuery(qb => qb.From.MyTable()) .AddQuery(qb => qb.From.NullStringNonnullable()) .AddQuery(qb => qb.From.NullStringNullable()) + .AddQuery(qb => qb.From.NullableUniqueLookup()) .AddQuery(qb => qb.From.MyLog()) .AddQuery(qb => qb.From.TestEvent()) .AddQuery(qb => qb.From.Admins()) @@ -195,6 +196,83 @@ int y ); }; + conn.Reducers.OnInsertNullableUniqueLookupRows += (ReducerEventContext ctx) => + { + Log.Info("Got InsertNullableUniqueLookupRows callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"InsertNullableUniqueLookupRows should commit, got {ctx.Event.Status}" + ); + ValidateNullableUniqueLookupRows(ctx); + + Log.Debug("Calling DeleteNullableUniqueLookupByNumber(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByNumber(null); + + Log.Debug("Calling DeleteNullableUniqueLookupByString(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByString(null); + + Log.Debug("Calling DeleteNullableUniqueLookupByUuid(null)"); + waiting++; + conn.Reducers.DeleteNullableUniqueLookupByUuid(null); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByNumber += ( + ReducerEventContext ctx, + uint? optionalNumber + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByNumber callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByNumber should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalNumber is null, $"Expected null optionalNumber, got {optionalNumber}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalNumber.Find((uint?)null) is null, + "Expected OptionalNumber.Find(null) to be absent after delete" + ); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByString += ( + ReducerEventContext ctx, + string? optionalString + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByString callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByString should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalString is null, $"Expected null optionalString, got {optionalString}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalString.Find(null) is null, + "Expected OptionalString.Find(null) to be absent after delete" + ); + }; + + conn.Reducers.OnDeleteNullableUniqueLookupByUuid += ( + ReducerEventContext ctx, + Uuid? optionalUuid + ) => + { + Log.Info("Got DeleteNullableUniqueLookupByUuid callback"); + waiting--; + Debug.Assert( + ctx.Event.Status is Status.Committed, + $"DeleteNullableUniqueLookupByUuid should commit, got {ctx.Event.Status}" + ); + Debug.Assert(optionalUuid is null, $"Expected null optionalUuid, got {optionalUuid}"); + Debug.Assert( + ctx.Db.NullableUniqueLookup.OptionalUuid.Find(null) is null, + "Expected OptionalUuid.Find(null) to be absent after delete" + ); + }; + conn.Reducers.OnUpdateWhereTest += ( ReducerEventContext ctx, uint id, @@ -463,6 +541,35 @@ void ValidateNullableVecView( } } +void ValidateNullableUniqueLookupRows(IRemoteDbContext conn) +{ + Log.Debug("Checking nullable unique lookup indexes..."); + + var numberNull = conn.Db.NullableUniqueLookup.OptionalNumber.Find((uint?)null); + Debug.Assert(numberNull is not null, "Expected OptionalNumber.Find(null) to find row 1"); + Debug.Assert(numberNull.Id == 1, $"Expected OptionalNumber null row id 1, got {numberNull.Id}"); + + var numberValue = conn.Db.NullableUniqueLookup.OptionalNumber.Find(7); + Debug.Assert(numberValue is not null, "Expected OptionalNumber.Find(7) to find row 2"); + Debug.Assert(numberValue.Id == 2, $"Expected OptionalNumber 7 row id 2, got {numberValue.Id}"); + + var stringNull = conn.Db.NullableUniqueLookup.OptionalString.Find(null); + Debug.Assert(stringNull is not null, "Expected OptionalString.Find(null) to find row 2"); + Debug.Assert(stringNull.Id == 2, $"Expected OptionalString null row id 2, got {stringNull.Id}"); + + var stringValue = conn.Db.NullableUniqueLookup.OptionalString.Find("alpha"); + Debug.Assert(stringValue is not null, "Expected OptionalString.Find(\"alpha\") to find row 1"); + Debug.Assert(stringValue.Id == 1, $"Expected OptionalString alpha row id 1, got {stringValue.Id}"); + + var uuidNull = conn.Db.NullableUniqueLookup.OptionalUuid.Find(null); + Debug.Assert(uuidNull is not null, "Expected OptionalUuid.Find(null) to find row 3"); + Debug.Assert(uuidNull.Id == 3, $"Expected OptionalUuid null row id 3, got {uuidNull.Id}"); + + var uuidValue = conn.Db.NullableUniqueLookup.OptionalUuid.Find(Uuid.NIL); + Debug.Assert(uuidValue is not null, "Expected OptionalUuid.Find(Uuid.NIL) to find row 1"); + Debug.Assert(uuidValue.Id == 1, $"Expected OptionalUuid NIL row id 1, got {uuidValue.Id}"); +} + void ValidateReducerErrorDoesNotContainStackTrace(Exception exception) { Debug.Assert( @@ -1303,6 +1410,10 @@ void OnSubscriptionApplied(SubscriptionEventContext context) waiting++; context.Reducers.InsertNullStringIntoNullable(); + Log.Debug("Calling InsertNullableUniqueLookupRows"); + waiting++; + context.Reducers.InsertNullableUniqueLookupRows(); + Log.Debug("Calling EmitTestEvent"); waiting++; context.Reducers.EmitTestEvent(EXPECTED_TEST_EVENT_NAME, EXPECTED_TEST_EVENT_VALUE); diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs new file mode 100644 index 00000000000..44d4c6364dd --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByNumber.g.cs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByNumberHandler(ReducerEventContext ctx, uint? optionalNumber); + public event DeleteNullableUniqueLookupByNumberHandler? OnDeleteNullableUniqueLookupByNumber; + + public void DeleteNullableUniqueLookupByNumber(uint? optionalNumber) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByNumber(optionalNumber)); + } + + public bool InvokeDeleteNullableUniqueLookupByNumber(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByNumber args) + { + if (OnDeleteNullableUniqueLookupByNumber == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByNumber( + ctx, + args.OptionalNumber + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByNumber : Reducer, IReducerArgs + { + [DataMember(Name = "optional_number")] + public uint? OptionalNumber; + + public DeleteNullableUniqueLookupByNumber(uint? OptionalNumber) + { + this.OptionalNumber = OptionalNumber; + } + + public DeleteNullableUniqueLookupByNumber() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_number"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs new file mode 100644 index 00000000000..b972eb25805 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByString.g.cs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByStringHandler(ReducerEventContext ctx, string? optionalString); + public event DeleteNullableUniqueLookupByStringHandler? OnDeleteNullableUniqueLookupByString; + + public void DeleteNullableUniqueLookupByString(string? optionalString) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByString(optionalString)); + } + + public bool InvokeDeleteNullableUniqueLookupByString(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByString args) + { + if (OnDeleteNullableUniqueLookupByString == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByString( + ctx, + args.OptionalString + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByString : Reducer, IReducerArgs + { + [DataMember(Name = "optional_string")] + public string? OptionalString; + + public DeleteNullableUniqueLookupByString(string? OptionalString) + { + this.OptionalString = OptionalString; + } + + public DeleteNullableUniqueLookupByString() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_string"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs new file mode 100644 index 00000000000..916d0c99643 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/DeleteNullableUniqueLookupByUuid.g.cs @@ -0,0 +1,66 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void DeleteNullableUniqueLookupByUuidHandler(ReducerEventContext ctx, SpacetimeDB.Uuid? optionalUuid); + public event DeleteNullableUniqueLookupByUuidHandler? OnDeleteNullableUniqueLookupByUuid; + + public void DeleteNullableUniqueLookupByUuid(SpacetimeDB.Uuid? optionalUuid) + { + conn.InternalCallReducer(new Reducer.DeleteNullableUniqueLookupByUuid(optionalUuid)); + } + + public bool InvokeDeleteNullableUniqueLookupByUuid(ReducerEventContext ctx, Reducer.DeleteNullableUniqueLookupByUuid args) + { + if (OnDeleteNullableUniqueLookupByUuid == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnDeleteNullableUniqueLookupByUuid( + ctx, + args.OptionalUuid + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class DeleteNullableUniqueLookupByUuid : Reducer, IReducerArgs + { + [DataMember(Name = "optional_uuid")] + public SpacetimeDB.Uuid? OptionalUuid; + + public DeleteNullableUniqueLookupByUuid(SpacetimeDB.Uuid? OptionalUuid) + { + this.OptionalUuid = OptionalUuid; + } + + public DeleteNullableUniqueLookupByUuid() + { + } + + string IReducerArgs.ReducerName => "delete_nullable_unique_lookup_by_uuid"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs new file mode 100644 index 00000000000..680bf18f902 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Reducers/InsertNullableUniqueLookupRows.g.cs @@ -0,0 +1,53 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteReducers : RemoteBase + { + public delegate void InsertNullableUniqueLookupRowsHandler(ReducerEventContext ctx); + public event InsertNullableUniqueLookupRowsHandler? OnInsertNullableUniqueLookupRows; + + public void InsertNullableUniqueLookupRows() + { + conn.InternalCallReducer(new Reducer.InsertNullableUniqueLookupRows()); + } + + public bool InvokeInsertNullableUniqueLookupRows(ReducerEventContext ctx, Reducer.InsertNullableUniqueLookupRows args) + { + if (OnInsertNullableUniqueLookupRows == null) + { + if (InternalOnUnhandledReducerError != null) + { + switch (ctx.Event.Status) + { + case Status.Failed(var reason): InternalOnUnhandledReducerError(ctx, new Exception(reason)); break; + case Status.OutOfEnergy(var _): InternalOnUnhandledReducerError(ctx, new Exception("out of energy")); break; + } + } + return false; + } + OnInsertNullableUniqueLookupRows( + ctx + ); + return true; + } + } + + public abstract partial class Reducer + { + [SpacetimeDB.Type] + [DataContract] + public sealed partial class InsertNullableUniqueLookupRows : Reducer, IReducerArgs + { + string IReducerArgs.ReducerName => "insert_nullable_unique_lookup_rows"; + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs index 0fa3dd38aa7..88521597075 100644 --- a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.4.1 (commit ed95086da83809e1e621aae0066b0970a4130a3e). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable @@ -47,6 +47,7 @@ public RemoteTables(DbConnection conn) AddTable(MyTable = new(conn)); AddTable(NullStringNonnullable = new(conn)); AddTable(NullStringNullable = new(conn)); + AddTable(NullableUniqueLookup = new(conn)); AddTable(NullableVec = new(conn)); AddTable(NullableVecView = new(conn)); AddTable(Player = new(conn)); @@ -589,6 +590,7 @@ public sealed class QueryBuilder new QueryBuilder().From.MyTable().ToSql(), new QueryBuilder().From.NullStringNonnullable().ToSql(), new QueryBuilder().From.NullStringNullable().ToSql(), + new QueryBuilder().From.NullableUniqueLookup().ToSql(), new QueryBuilder().From.NullableVec().ToSql(), new QueryBuilder().From.NullableVecView().ToSql(), new QueryBuilder().From.Player().ToSql(), @@ -641,6 +643,7 @@ public sealed class From public global::SpacetimeDB.Table MyTable() => new("my_table", new MyTableCols("my_table"), new MyTableIxCols("my_table")); public global::SpacetimeDB.Table NullStringNonnullable() => new("null_string_nonnullable", new NullStringNonnullableCols("null_string_nonnullable"), new NullStringNonnullableIxCols("null_string_nonnullable")); public global::SpacetimeDB.Table NullStringNullable() => new("null_string_nullable", new NullStringNullableCols("null_string_nullable"), new NullStringNullableIxCols("null_string_nullable")); + public global::SpacetimeDB.Table NullableUniqueLookup() => new("nullable_unique_lookup", new NullableUniqueLookupCols("nullable_unique_lookup"), new NullableUniqueLookupIxCols("nullable_unique_lookup")); public global::SpacetimeDB.Table NullableVec() => new("nullable_vec", new NullableVecCols("nullable_vec"), new NullableVecIxCols("nullable_vec")); public global::SpacetimeDB.Table NullableVecView() => new("nullable_vec_view", new NullableVecViewCols("nullable_vec_view"), new NullableVecViewIxCols("nullable_vec_view")); public global::SpacetimeDB.Table Player() => new("player", new PlayerCols("player"), new PlayerIxCols("player")); @@ -753,8 +756,12 @@ protected override bool Dispatch(IReducerEventContext context, Reducer reducer) Reducer.AddEqualityPerson args => Reducers.InvokeAddEqualityPerson(eventContext, args), Reducer.AddEqualityProduct args => Reducers.InvokeAddEqualityProduct(eventContext, args), Reducer.Delete args => Reducers.InvokeDelete(eventContext, args), + Reducer.DeleteNullableUniqueLookupByNumber args => Reducers.InvokeDeleteNullableUniqueLookupByNumber(eventContext, args), + Reducer.DeleteNullableUniqueLookupByString args => Reducers.InvokeDeleteNullableUniqueLookupByString(eventContext, args), + Reducer.DeleteNullableUniqueLookupByUuid args => Reducers.InvokeDeleteNullableUniqueLookupByUuid(eventContext, args), Reducer.EmitTestEvent args => Reducers.InvokeEmitTestEvent(eventContext, args), Reducer.InsertEmptyStringIntoNonNullable args => Reducers.InvokeInsertEmptyStringIntoNonNullable(eventContext, args), + Reducer.InsertNullableUniqueLookupRows args => Reducers.InvokeInsertNullableUniqueLookupRows(eventContext, args), Reducer.InsertNullStringIntoNonNullable args => Reducers.InvokeInsertNullStringIntoNonNullable(eventContext, args), Reducer.InsertNullStringIntoNullable args => Reducers.InvokeInsertNullStringIntoNullable(eventContext, args), Reducer.InsertResult args => Reducers.InvokeInsertResult(eventContext, args), diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs new file mode 100644 index 00000000000..29c4f329ae2 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Tables/NullableUniqueLookup.g.cs @@ -0,0 +1,101 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using SpacetimeDB.BSATN; +using SpacetimeDB.ClientApi; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + public sealed partial class RemoteTables + { + public sealed class NullableUniqueLookupHandle : RemoteTableHandle + { + protected override string RemoteTableName => "nullable_unique_lookup"; + + public sealed class IdUniqueIndex : UniqueIndexBase + { + protected override uint GetKey(NullableUniqueLookup row) => row.Id; + + public IdUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly IdUniqueIndex Id; + + public sealed class OptionalNumberUniqueIndex : NullableUniqueIndexBase + { + protected override uint? GetKey(NullableUniqueLookup row) => row.OptionalNumber; + + public OptionalNumberUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalNumberUniqueIndex OptionalNumber; + + public sealed class OptionalStringUniqueIndex : NullableUniqueIndexBase + { + protected override string? GetKey(NullableUniqueLookup row) => row.OptionalString; + + public OptionalStringUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalStringUniqueIndex OptionalString; + + public sealed class OptionalUuidUniqueIndex : NullableUniqueIndexBase + { + protected override SpacetimeDB.Uuid? GetKey(NullableUniqueLookup row) => row.OptionalUuid; + + public OptionalUuidUniqueIndex(NullableUniqueLookupHandle table) : base(table) { } + } + + public readonly OptionalUuidUniqueIndex OptionalUuid; + + internal NullableUniqueLookupHandle(DbConnection conn) : base(conn) + { + Id = new(this); + OptionalNumber = new(this); + OptionalString = new(this); + OptionalUuid = new(this); + } + + protected override object GetPrimaryKey(NullableUniqueLookup row) => row.Id; + } + + public readonly NullableUniqueLookupHandle NullableUniqueLookup; + } + + public sealed class NullableUniqueLookupCols + { + public global::SpacetimeDB.Col Id { get; } + public global::SpacetimeDB.Col OptionalNumber { get; } + public global::SpacetimeDB.Col OptionalString { get; } + public global::SpacetimeDB.Col OptionalUuid { get; } + + public NullableUniqueLookupCols(string tableName) + { + Id = new global::SpacetimeDB.Col(tableName, "id"); + OptionalNumber = new global::SpacetimeDB.Col(tableName, "optional_number"); + OptionalString = new global::SpacetimeDB.Col(tableName, "optional_string"); + OptionalUuid = new global::SpacetimeDB.Col(tableName, "optional_uuid"); + } + } + + public sealed class NullableUniqueLookupIxCols + { + public global::SpacetimeDB.IxCol Id { get; } + public global::SpacetimeDB.IxCol OptionalNumber { get; } + public global::SpacetimeDB.IxCol OptionalString { get; } + public global::SpacetimeDB.IxCol OptionalUuid { get; } + + public NullableUniqueLookupIxCols(string tableName) + { + Id = new global::SpacetimeDB.IxCol(tableName, "id"); + OptionalNumber = new global::SpacetimeDB.IxCol(tableName, "optional_number"); + OptionalString = new global::SpacetimeDB.IxCol(tableName, "optional_string"); + OptionalUuid = new global::SpacetimeDB.IxCol(tableName, "optional_uuid"); + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs new file mode 100644 index 00000000000..7182b19ff57 --- /dev/null +++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/Types/NullableUniqueLookup.g.cs @@ -0,0 +1,42 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#nullable enable + +using System; +using System.Collections.Generic; +using System.Runtime.Serialization; + +namespace SpacetimeDB.Types +{ + [SpacetimeDB.Type] + [DataContract] + public sealed partial class NullableUniqueLookup + { + [DataMember(Name = "id")] + public uint Id; + [DataMember(Name = "optional_number")] + public uint? OptionalNumber; + [DataMember(Name = "optional_string")] + public string? OptionalString; + [DataMember(Name = "optional_uuid")] + public SpacetimeDB.Uuid? OptionalUuid; + + public NullableUniqueLookup( + uint Id, + uint? OptionalNumber, + string? OptionalString, + SpacetimeDB.Uuid? OptionalUuid + ) + { + this.Id = Id; + this.OptionalNumber = OptionalNumber; + this.OptionalString = OptionalString; + this.OptionalUuid = OptionalUuid; + } + + public NullableUniqueLookup() + { + } + } +} diff --git a/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs index 948b4e405d7..91a4f49cb17 100644 --- a/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/procedure-client/module_bindings/SpacetimeDBClient.g.cs @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.0.4 (commit dfc726be29516b8cdecc651f5c9705026a624a04). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable diff --git a/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs index ba9311b5d45..f89d47117f0 100644 --- a/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs +++ b/sdks/csharp/examples~/regression-tests/republishing/client/module_bindings/SpacetimeDBClient.g.cs @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.0.0 (commit 4cce69765507c1815979d39572b4a52864f5c3d2). +// This was generated using spacetimedb cli version 2.7.0 (commit 5f2a3f87a144481aa88567616b3352d78d0be82e). #nullable enable diff --git a/sdks/csharp/examples~/regression-tests/server/Lib.cs b/sdks/csharp/examples~/regression-tests/server/Lib.cs index e3391b710ff..2ec11174a4c 100644 --- a/sdks/csharp/examples~/regression-tests/server/Lib.cs +++ b/sdks/csharp/examples~/regression-tests/server/Lib.cs @@ -172,6 +172,22 @@ public partial struct NullStringNullable public string? Name; } + [SpacetimeDB.Table(Accessor = "nullable_unique_lookup", Public = true)] + public partial struct NullableUniqueLookup + { + [SpacetimeDB.PrimaryKey] + public uint Id; + + [SpacetimeDB.Unique] + public uint? OptionalNumber; + + [SpacetimeDB.Unique] + public string? OptionalString; + + [SpacetimeDB.Unique] + public Uuid? OptionalUuid; + } + [SpacetimeDB.Table(Accessor = "view_pk_player", Public = true)] public partial struct ViewPkPlayer { @@ -598,6 +614,56 @@ public static void InsertNullStringIntoNullable(ReducerContext ctx) ctx.Db.null_string_nullable.Insert(new NullStringNullable { Name = null }); } + [SpacetimeDB.Reducer] + public static void InsertNullableUniqueLookupRows(ReducerContext ctx) + { + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 1, + OptionalNumber = null, + OptionalString = "alpha", + OptionalUuid = Uuid.NIL, + } + ); + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 2, + OptionalNumber = 7, + OptionalString = null, + OptionalUuid = Uuid.MAX, + } + ); + ctx.Db.nullable_unique_lookup.Insert( + new NullableUniqueLookup + { + Id = 3, + OptionalNumber = 8, + OptionalString = "beta", + OptionalUuid = null, + } + ); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByNumber(ReducerContext ctx, uint? optionalNumber) + { + ctx.Db.nullable_unique_lookup.OptionalNumber.Delete(optionalNumber); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByString(ReducerContext ctx, string? optionalString) + { + ctx.Db.nullable_unique_lookup.OptionalString.Delete(optionalString); + } + + [SpacetimeDB.Reducer] + public static void DeleteNullableUniqueLookupByUuid(ReducerContext ctx, Uuid? optionalUuid) + { + ctx.Db.nullable_unique_lookup.OptionalUuid.Delete(optionalUuid); + } + [SpacetimeDB.Reducer] public static void InsertWhereTest(ReducerContext ctx, uint id, uint value, string name) { diff --git a/sdks/csharp/src/Table.cs b/sdks/csharp/src/Table.cs index 620d99fffd1..8323c85fba7 100644 --- a/sdks/csharp/src/Table.cs +++ b/sdks/csharp/src/Table.cs @@ -154,6 +154,76 @@ public IEnumerable Filter(Column value) => cache.TryGetValue(value, out var rows) ? rows : Enumerable.Empty(); } + public abstract class NullableIndexBase + { + protected readonly struct IndexKey : IEquatable + { + private static readonly EqualityComparer Comparer = EqualityComparer.Default; + + private readonly Column value; + + public IndexKey(Column value) + { + this.value = value; + } + + public bool Equals(IndexKey other) => Comparer.Equals(value, other.value); + + public override bool Equals(object? obj) => obj is IndexKey other && Equals(other); + + public override int GetHashCode() => Comparer.GetHashCode(value!); + } + + protected abstract Column GetKey(Row row); + } + + public abstract class NullableUniqueIndexBase : NullableIndexBase + { + private readonly Dictionary cache = new(); + + public NullableUniqueIndexBase(RemoteTableHandleBase table) + { + table.OnInternalInsert += row => cache.Add(new IndexKey(GetKey(row)), row); + table.OnInternalDelete += row => cache.Remove(new IndexKey(GetKey(row))); + } + + public Row? Find(Column value) => cache.TryGetValue(new IndexKey(value), out var row) ? row : null; + } + + public abstract class NullableBTreeIndexBase : NullableIndexBase + { + // TODO: change to SortedDictionary when adding support for range queries. + private readonly Dictionary> cache = new(); + + public NullableBTreeIndexBase(RemoteTableHandleBase table) + { + table.OnInternalInsert += row => + { + var key = new IndexKey(GetKey(row)); + if (!cache.TryGetValue(key, out var rows)) + { + rows = new(); + cache.Add(key, rows); + } + rows.Add(row); + }; + + table.OnInternalDelete += row => + { + var key = new IndexKey(GetKey(row)); + var keyCache = cache[key]; + keyCache.Remove(row); + if (keyCache.Count == 0) + { + cache.Remove(key); + } + }; + } + + public IEnumerable Filter(Column value) => + cache.TryGetValue(new IndexKey(value), out var rows) ? rows : Enumerable.Empty(); + } + /// /// Represents a parsed update to a table, storing the changes as a multi-dictionary delta /// mapping primary keys to their corresponding row updates. diff --git a/sdks/rust/tests/test.rs b/sdks/rust/tests/test.rs index 9a2edaa13d6..7c5b3c13998 100644 --- a/sdks/rust/tests/test.rs +++ b/sdks/rust/tests/test.rs @@ -211,7 +211,7 @@ macro_rules! declare_tests_with_suffix { #[test] fn update_uuid() { - make_test("delete-uuid").run(); + make_test("update-uuid").run(); } #[test] diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp index f9344999447..f7d830dc9aa 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp @@ -76,6 +76,23 @@ #include "ModuleBindings/Tables/UniqueI64Table.g.h" #include "ModuleBindings/Tables/UniqueI8Table.g.h" #include "ModuleBindings/Tables/UniqueIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" #include "ModuleBindings/Tables/UniqueStringTable.g.h" #include "ModuleBindings/Tables/UniqueU128Table.g.h" #include "ModuleBindings/Tables/UniqueU16Table.g.h" @@ -195,6 +212,23 @@ UDbConnection::UDbConnection(const FObjectInitializer& ObjectInitializer) : Supe RegisterTable(TEXT("unique_i_64"), Db->UniqueI64); RegisterTable(TEXT("unique_i_8"), Db->UniqueI8); RegisterTable(TEXT("unique_identity"), Db->UniqueIdentity); + RegisterTable(TEXT("unique_option_bool"), Db->UniqueOptionBool); + RegisterTable(TEXT("unique_option_connection_id"), Db->UniqueOptionConnectionId); + RegisterTable(TEXT("unique_option_i_128"), Db->UniqueOptionI128); + RegisterTable(TEXT("unique_option_i_16"), Db->UniqueOptionI16); + RegisterTable(TEXT("unique_option_i_256"), Db->UniqueOptionI256); + RegisterTable(TEXT("unique_option_i_32"), Db->UniqueOptionI32); + RegisterTable(TEXT("unique_option_i_64"), Db->UniqueOptionI64); + RegisterTable(TEXT("unique_option_i_8"), Db->UniqueOptionI8); + RegisterTable(TEXT("unique_option_identity"), Db->UniqueOptionIdentity); + RegisterTable(TEXT("unique_option_string"), Db->UniqueOptionString); + RegisterTable(TEXT("unique_option_u_128"), Db->UniqueOptionU128); + RegisterTable(TEXT("unique_option_u_16"), Db->UniqueOptionU16); + RegisterTable(TEXT("unique_option_u_256"), Db->UniqueOptionU256); + RegisterTable(TEXT("unique_option_u_32"), Db->UniqueOptionU32); + RegisterTable(TEXT("unique_option_u_64"), Db->UniqueOptionU64); + RegisterTable(TEXT("unique_option_u_8"), Db->UniqueOptionU8); + RegisterTable(TEXT("unique_option_uuid"), Db->UniqueOptionUuid); RegisterTable(TEXT("unique_string"), Db->UniqueString); RegisterTable(TEXT("unique_u_128"), Db->UniqueU128); RegisterTable(TEXT("unique_u_16"), Db->UniqueU16); @@ -336,6 +370,23 @@ void URemoteTables::Initialize() UniqueI64 = NewObject(this); UniqueI8 = NewObject(this); UniqueIdentity = NewObject(this); + UniqueOptionBool = NewObject(this); + UniqueOptionConnectionId = NewObject(this); + UniqueOptionI128 = NewObject(this); + UniqueOptionI16 = NewObject(this); + UniqueOptionI256 = NewObject(this); + UniqueOptionI32 = NewObject(this); + UniqueOptionI64 = NewObject(this); + UniqueOptionI8 = NewObject(this); + UniqueOptionIdentity = NewObject(this); + UniqueOptionString = NewObject(this); + UniqueOptionU128 = NewObject(this); + UniqueOptionU16 = NewObject(this); + UniqueOptionU256 = NewObject(this); + UniqueOptionU32 = NewObject(this); + UniqueOptionU64 = NewObject(this); + UniqueOptionU8 = NewObject(this); + UniqueOptionUuid = NewObject(this); UniqueString = NewObject(this); UniqueU128 = NewObject(this); UniqueU16 = NewObject(this); @@ -446,6 +497,23 @@ void URemoteTables::Initialize() UniqueI64->PostInitialize(); UniqueI8->PostInitialize(); UniqueIdentity->PostInitialize(); + UniqueOptionBool->PostInitialize(); + UniqueOptionConnectionId->PostInitialize(); + UniqueOptionI128->PostInitialize(); + UniqueOptionI16->PostInitialize(); + UniqueOptionI256->PostInitialize(); + UniqueOptionI32->PostInitialize(); + UniqueOptionI64->PostInitialize(); + UniqueOptionI8->PostInitialize(); + UniqueOptionIdentity->PostInitialize(); + UniqueOptionString->PostInitialize(); + UniqueOptionU128->PostInitialize(); + UniqueOptionU16->PostInitialize(); + UniqueOptionU256->PostInitialize(); + UniqueOptionU32->PostInitialize(); + UniqueOptionU64->PostInitialize(); + UniqueOptionU8->PostInitialize(); + UniqueOptionUuid->PostInitialize(); UniqueString->PostInitialize(); UniqueU128->PostInitialize(); UniqueU16->PostInitialize(); @@ -3198,7 +3266,7 @@ bool URemoteReducers::InvokeDeleteAllUniqueIdentityWithArgs(const FReducerEventC return true; } -void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -3206,45 +3274,45 @@ void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) return; } - FDeleteAllUniqueStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueString(ReducerArgs)); } + FDeleteAllUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionBool(const FReducerEventContext& Context, const UDeleteAllUniqueOptionBoolReducer* Args) { - if (!OnDeleteAllUniqueString.IsBound()) + if (!OnDeleteAllUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionBool")); } return false; } - OnDeleteAllUniqueString.Broadcast(Context, Args->S, Args->Data); + OnDeleteAllUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionBoolArgs& Args) { - if (!OnDeleteAllUniqueString.IsBound()) + if (!OnDeleteAllUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionBool")); } return false; } - OnDeleteAllUniqueString.Broadcast(Context, Args.S, Args.Data); + OnDeleteAllUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -3252,45 +3320,45 @@ void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const in return; } - FDeleteAllUniqueU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU128(ReducerArgs)); } + FDeleteAllUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteAllUniqueOptionConnectionIdReducer* Args) { - if (!OnDeleteAllUniqueU128.IsBound()) + if (!OnDeleteAllUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionConnectionId")); } return false; } - OnDeleteAllUniqueU128.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionConnectionIdArgs& Args) { - if (!OnDeleteAllUniqueU128.IsBound()) + if (!OnDeleteAllUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionConnectionId")); } return false; } - OnDeleteAllUniqueU128.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -3298,45 +3366,45 @@ void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) return; } - FDeleteAllUniqueU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU16(ReducerArgs)); } + FDeleteAllUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI128Reducer* Args) { - if (!OnDeleteAllUniqueU16.IsBound()) + if (!OnDeleteAllUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI128")); } return false; } - OnDeleteAllUniqueU16.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI128Args& Args) { - if (!OnDeleteAllUniqueU16.IsBound()) + if (!OnDeleteAllUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI128")); } return false; } - OnDeleteAllUniqueU16.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -3344,45 +3412,45 @@ void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const in return; } - FDeleteAllUniqueU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU256(ReducerArgs)); } + FDeleteAllUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU256(const FReducerEventContext& Context, const UDeleteAllUniqueU256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI16Reducer* Args) { - if (!OnDeleteAllUniqueU256.IsBound()) + if (!OnDeleteAllUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI16")); } return false; } - OnDeleteAllUniqueU256.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU256Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI16Args& Args) { - if (!OnDeleteAllUniqueU256.IsBound()) + if (!OnDeleteAllUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI16")); } return false; } - OnDeleteAllUniqueU256.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -3390,45 +3458,45 @@ void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) return; } - FDeleteAllUniqueU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU32(ReducerArgs)); } + FDeleteAllUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU32(const FReducerEventContext& Context, const UDeleteAllUniqueU32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI256Reducer* Args) { - if (!OnDeleteAllUniqueU32.IsBound()) + if (!OnDeleteAllUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI256")); } return false; } - OnDeleteAllUniqueU32.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI256Args& Args) { - if (!OnDeleteAllUniqueU32.IsBound()) + if (!OnDeleteAllUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI256")); } return false; } - OnDeleteAllUniqueU32.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -3436,45 +3504,45 @@ void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) return; } - FDeleteAllUniqueU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU64(ReducerArgs)); } + FDeleteAllUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU64(const FReducerEventContext& Context, const UDeleteAllUniqueU64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI32Reducer* Args) { - if (!OnDeleteAllUniqueU64.IsBound()) + if (!OnDeleteAllUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI32")); } return false; } - OnDeleteAllUniqueU64.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI32Args& Args) { - if (!OnDeleteAllUniqueU64.IsBound()) + if (!OnDeleteAllUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI32")); } return false; } - OnDeleteAllUniqueU64.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -3482,45 +3550,45 @@ void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) return; } - FDeleteAllUniqueU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU8(ReducerArgs)); } + FDeleteAllUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueU8(const FReducerEventContext& Context, const UDeleteAllUniqueU8Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI64Reducer* Args) { - if (!OnDeleteAllUniqueU8.IsBound()) + if (!OnDeleteAllUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI64")); } return false; } - OnDeleteAllUniqueU8.Broadcast(Context, Args->N, Args->Data); + OnDeleteAllUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU8Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI64Args& Args) { - if (!OnDeleteAllUniqueU8.IsBound()) + if (!OnDeleteAllUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI64")); } return false; } - OnDeleteAllUniqueU8.Broadcast(Context, Args.N, Args.Data); + OnDeleteAllUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::DeleteAllUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -3528,45 +3596,45 @@ void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 return; } - FDeleteAllUniqueUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueUuid(ReducerArgs)); } + FDeleteAllUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllUniqueUuid(const FReducerEventContext& Context, const UDeleteAllUniqueUuidReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI8Reducer* Args) { - if (!OnDeleteAllUniqueUuid.IsBound()) + if (!OnDeleteAllUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI8")); } return false; } - OnDeleteAllUniqueUuid.Broadcast(Context, Args->U, Args->Data); + OnDeleteAllUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueUuidArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI8Args& Args) { - if (!OnDeleteAllUniqueUuid.IsBound()) + if (!OnDeleteAllUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionI8")); } return false; } - OnDeleteAllUniqueUuid.Broadcast(Context, Args.U, Args.Data); + OnDeleteAllUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecBool(const TArray& B) +void URemoteReducers::DeleteAllUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -3574,45 +3642,45 @@ void URemoteReducers::DeleteAllVecBool(const TArray& B) return; } - FDeleteAllVecBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecBool(ReducerArgs)); } + FDeleteAllUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecBool(const FReducerEventContext& Context, const UDeleteAllVecBoolReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteAllUniqueOptionIdentityReducer* Args) { - if (!OnDeleteAllVecBool.IsBound()) + if (!OnDeleteAllUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionIdentity")); } return false; } - OnDeleteAllVecBool.Broadcast(Context, Args->B); + OnDeleteAllUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllVecBoolArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionIdentityArgs& Args) { - if (!OnDeleteAllVecBool.IsBound()) + if (!OnDeleteAllUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionIdentity")); } return false; } - OnDeleteAllVecBool.Broadcast(Context, Args.B); + OnDeleteAllUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -3620,45 +3688,45 @@ void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) return; } - FDeleteAllVecByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecByteStruct(ReducerArgs)); } + FDeleteAllUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecByteStruct(const FReducerEventContext& Context, const UDeleteAllVecByteStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionString(const FReducerEventContext& Context, const UDeleteAllUniqueOptionStringReducer* Args) { - if (!OnDeleteAllVecByteStruct.IsBound()) + if (!OnDeleteAllUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionString")); } return false; } - OnDeleteAllVecByteStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecByteStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecByteStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionStringArgs& Args) { - if (!OnDeleteAllVecByteStruct.IsBound()) + if (!OnDeleteAllUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionString")); } return false; } - OnDeleteAllVecByteStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEnumWithPayload(const TArray& E) +void URemoteReducers::DeleteAllUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -3666,45 +3734,45 @@ void URemoteReducers::DeleteAllVecEnumWithPayload(const TArrayCallReducerTyped(TEXT("delete_all_vec_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEnumWithPayload(ReducerArgs)); } + FDeleteAllUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEnumWithPayload(const FReducerEventContext& Context, const UDeleteAllVecEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU128Reducer* Args) { - if (!OnDeleteAllVecEnumWithPayload.IsBound()) + if (!OnDeleteAllUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU128")); } return false; } - OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args->E); + OnDeleteAllUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU128Args& Args) { - if (!OnDeleteAllVecEnumWithPayload.IsBound()) + if (!OnDeleteAllUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU128")); } return false; } - OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args.E); + OnDeleteAllUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -3712,45 +3780,45 @@ void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArrayCallReducerTyped(TEXT("delete_all_vec_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryPrimitiveStruct(ReducerArgs)); } + FDeleteAllUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU16Reducer* Args) { - if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU16")); } return false; } - OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU16Args& Args) { - if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU16")); } return false; } - OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecEveryVecStruct(const TArray& S) +void URemoteReducers::DeleteAllUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -3758,45 +3826,45 @@ void URemoteReducers::DeleteAllVecEveryVecStruct(const TArrayCallReducerTyped(TEXT("delete_all_vec_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryVecStruct(ReducerArgs)); } + FDeleteAllUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecEveryVecStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryVecStructReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU256Reducer* Args) { - if (!OnDeleteAllVecEveryVecStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU256")); } return false; } - OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args->S); + OnDeleteAllUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryVecStructArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU256Args& Args) { - if (!OnDeleteAllVecEveryVecStruct.IsBound()) + if (!OnDeleteAllUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU256")); } return false; } - OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args.S); + OnDeleteAllUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecF32(const TArray& F) +void URemoteReducers::DeleteAllUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -3804,45 +3872,45 @@ void URemoteReducers::DeleteAllVecF32(const TArray& F) return; } - FDeleteAllVecF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF32(ReducerArgs)); } + FDeleteAllUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecF32(const FReducerEventContext& Context, const UDeleteAllVecF32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU32Reducer* Args) { - if (!OnDeleteAllVecF32.IsBound()) + if (!OnDeleteAllUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU32")); } return false; } - OnDeleteAllVecF32.Broadcast(Context, Args->F); + OnDeleteAllUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecF32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU32Args& Args) { - if (!OnDeleteAllVecF32.IsBound()) + if (!OnDeleteAllUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU32")); } return false; } - OnDeleteAllVecF32.Broadcast(Context, Args.F); + OnDeleteAllUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecF64(const TArray& F) +void URemoteReducers::DeleteAllUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -3850,45 +3918,45 @@ void URemoteReducers::DeleteAllVecF64(const TArray& F) return; } - FDeleteAllVecF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF64(ReducerArgs)); } + FDeleteAllUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecF64(const FReducerEventContext& Context, const UDeleteAllVecF64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU64Reducer* Args) { - if (!OnDeleteAllVecF64.IsBound()) + if (!OnDeleteAllUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU64")); } return false; } - OnDeleteAllVecF64.Broadcast(Context, Args->F); + OnDeleteAllUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecF64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU64Args& Args) { - if (!OnDeleteAllVecF64.IsBound()) + if (!OnDeleteAllUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU64")); } return false; } - OnDeleteAllVecF64.Broadcast(Context, Args.F); + OnDeleteAllUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI128(const TArray& N) +void URemoteReducers::DeleteAllUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -3896,45 +3964,45 @@ void URemoteReducers::DeleteAllVecI128(const TArray& N) return; } - FDeleteAllVecI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI128(ReducerArgs)); } + FDeleteAllUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI128(const FReducerEventContext& Context, const UDeleteAllVecI128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU8Reducer* Args) { - if (!OnDeleteAllVecI128.IsBound()) + if (!OnDeleteAllUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU8")); } return false; } - OnDeleteAllVecI128.Broadcast(Context, Args->N); + OnDeleteAllUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI128Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU8Args& Args) { - if (!OnDeleteAllVecI128.IsBound()) + if (!OnDeleteAllUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionU8")); } return false; } - OnDeleteAllVecI128.Broadcast(Context, Args.N); + OnDeleteAllUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI16(const TArray& N) +void URemoteReducers::DeleteAllUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -3942,45 +4010,45 @@ void URemoteReducers::DeleteAllVecI16(const TArray& N) return; } - FDeleteAllVecI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI16(ReducerArgs)); } + FDeleteAllUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI16(const FReducerEventContext& Context, const UDeleteAllVecI16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteAllUniqueOptionUuidReducer* Args) { - if (!OnDeleteAllVecI16.IsBound()) + if (!OnDeleteAllUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionUuid")); } return false; } - OnDeleteAllVecI16.Broadcast(Context, Args->N); + OnDeleteAllUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI16Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionUuidArgs& Args) { - if (!OnDeleteAllVecI16.IsBound()) + if (!OnDeleteAllUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueOptionUuid")); } return false; } - OnDeleteAllVecI16.Broadcast(Context, Args.N); + OnDeleteAllUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI256(const TArray& N) +void URemoteReducers::DeleteAllUniqueString(const FString& S, const int32 Data) { if (!Conn) { @@ -3988,45 +4056,45 @@ void URemoteReducers::DeleteAllVecI256(const TArray& N) return; } - FDeleteAllVecI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI256(ReducerArgs)); } + FDeleteAllUniqueStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI256(const FReducerEventContext& Context, const UDeleteAllVecI256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args) { - if (!OnDeleteAllVecI256.IsBound()) + if (!OnDeleteAllUniqueString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); } return false; } - OnDeleteAllVecI256.Broadcast(Context, Args->N); + OnDeleteAllUniqueString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI256Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args) { - if (!OnDeleteAllVecI256.IsBound()) + if (!OnDeleteAllUniqueString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueString")); } return false; } - OnDeleteAllVecI256.Broadcast(Context, Args.N); + OnDeleteAllUniqueString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI32(const TArray& N) +void URemoteReducers::DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -4034,45 +4102,45 @@ void URemoteReducers::DeleteAllVecI32(const TArray& N) return; } - FDeleteAllVecI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI32(ReducerArgs)); } + FDeleteAllUniqueU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI32(const FReducerEventContext& Context, const UDeleteAllVecI32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args) { - if (!OnDeleteAllVecI32.IsBound()) + if (!OnDeleteAllUniqueU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); } return false; } - OnDeleteAllVecI32.Broadcast(Context, Args->N); + OnDeleteAllUniqueU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI32Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args) { - if (!OnDeleteAllVecI32.IsBound()) + if (!OnDeleteAllUniqueU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU128")); } return false; } - OnDeleteAllVecI32.Broadcast(Context, Args.N); + OnDeleteAllUniqueU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI64(const TArray& N) +void URemoteReducers::DeleteAllUniqueU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -4080,45 +4148,45 @@ void URemoteReducers::DeleteAllVecI64(const TArray& N) return; } - FDeleteAllVecI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI64(ReducerArgs)); } + FDeleteAllUniqueU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI64(const FReducerEventContext& Context, const UDeleteAllVecI64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args) { - if (!OnDeleteAllVecI64.IsBound()) + if (!OnDeleteAllUniqueU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); } return false; } - OnDeleteAllVecI64.Broadcast(Context, Args->N); + OnDeleteAllUniqueU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI64Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args) { - if (!OnDeleteAllVecI64.IsBound()) + if (!OnDeleteAllUniqueU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU16")); } return false; } - OnDeleteAllVecI64.Broadcast(Context, Args.N); + OnDeleteAllUniqueU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecI8(const TArray& N) +void URemoteReducers::DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -4126,45 +4194,45 @@ void URemoteReducers::DeleteAllVecI8(const TArray& N) return; } - FDeleteAllVecI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI8(ReducerArgs)); } + FDeleteAllUniqueU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecI8(const FReducerEventContext& Context, const UDeleteAllVecI8Reducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU256(const FReducerEventContext& Context, const UDeleteAllUniqueU256Reducer* Args) { - if (!OnDeleteAllVecI8.IsBound()) + if (!OnDeleteAllUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); } return false; } - OnDeleteAllVecI8.Broadcast(Context, Args->N); + OnDeleteAllUniqueU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecI8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI8Args& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU256Args& Args) { - if (!OnDeleteAllVecI8.IsBound()) + if (!OnDeleteAllUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU256")); } return false; } - OnDeleteAllVecI8.Broadcast(Context, Args.N); + OnDeleteAllUniqueU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecIdentity(const TArray& I) +void URemoteReducers::DeleteAllUniqueU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -4172,45 +4240,45 @@ void URemoteReducers::DeleteAllVecIdentity(const TArray& I return; } - FDeleteAllVecIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecIdentity(ReducerArgs)); } + FDeleteAllUniqueU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecIdentity(const FReducerEventContext& Context, const UDeleteAllVecIdentityReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU32(const FReducerEventContext& Context, const UDeleteAllUniqueU32Reducer* Args) { - if (!OnDeleteAllVecIdentity.IsBound()) + if (!OnDeleteAllUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); } return false; } - OnDeleteAllVecIdentity.Broadcast(Context, Args->I); + OnDeleteAllUniqueU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllVecIdentityArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU32Args& Args) { - if (!OnDeleteAllVecIdentity.IsBound()) + if (!OnDeleteAllUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU32")); } return false; } - OnDeleteAllVecIdentity.Broadcast(Context, Args.I); + OnDeleteAllUniqueU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) +void URemoteReducers::DeleteAllUniqueU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -4218,45 +4286,45 @@ void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) return; } - FDeleteAllVecSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecSimpleEnum(ReducerArgs)); } + FDeleteAllUniqueU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecSimpleEnum(const FReducerEventContext& Context, const UDeleteAllVecSimpleEnumReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU64(const FReducerEventContext& Context, const UDeleteAllUniqueU64Reducer* Args) { - if (!OnDeleteAllVecSimpleEnum.IsBound()) + if (!OnDeleteAllUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); } return false; } - OnDeleteAllVecSimpleEnum.Broadcast(Context, Args->E); + OnDeleteAllUniqueU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FDeleteAllVecSimpleEnumArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU64Args& Args) { - if (!OnDeleteAllVecSimpleEnum.IsBound()) + if (!OnDeleteAllUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU64")); } return false; } - OnDeleteAllVecSimpleEnum.Broadcast(Context, Args.E); + OnDeleteAllUniqueU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecString(const TArray& S) +void URemoteReducers::DeleteAllUniqueU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -4264,45 +4332,45 @@ void URemoteReducers::DeleteAllVecString(const TArray& S) return; } - FDeleteAllVecStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecString(ReducerArgs)); } + FDeleteAllUniqueU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecString(const FReducerEventContext& Context, const UDeleteAllVecStringReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueU8(const FReducerEventContext& Context, const UDeleteAllUniqueU8Reducer* Args) { - if (!OnDeleteAllVecString.IsBound()) + if (!OnDeleteAllUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); } return false; } - OnDeleteAllVecString.Broadcast(Context, Args->S); + OnDeleteAllUniqueU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecStringWithArgs(const FReducerEventContext& Context, const FDeleteAllVecStringArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU8Args& Args) { - if (!OnDeleteAllVecString.IsBound()) + if (!OnDeleteAllUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueU8")); } return false; } - OnDeleteAllVecString.Broadcast(Context, Args.S); + OnDeleteAllUniqueU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::DeleteAllVecTimestamp(const TArray& T) +void URemoteReducers::DeleteAllUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -4310,45 +4378,45 @@ void URemoteReducers::DeleteAllVecTimestamp(const TArray& return; } - FDeleteAllVecTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecTimestamp(ReducerArgs)); } + FDeleteAllUniqueUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecTimestamp(const FReducerEventContext& Context, const UDeleteAllVecTimestampReducer* Args) +bool URemoteReducers::InvokeDeleteAllUniqueUuid(const FReducerEventContext& Context, const UDeleteAllUniqueUuidReducer* Args) { - if (!OnDeleteAllVecTimestamp.IsBound()) + if (!OnDeleteAllUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); } return false; } - OnDeleteAllVecTimestamp.Broadcast(Context, Args->T); + OnDeleteAllUniqueUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeDeleteAllVecTimestampWithArgs(const FReducerEventContext& Context, const FDeleteAllVecTimestampArgs& Args) +bool URemoteReducers::InvokeDeleteAllUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueUuidArgs& Args) { - if (!OnDeleteAllVecTimestamp.IsBound()) + if (!OnDeleteAllUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllUniqueUuid")); } return false; } - OnDeleteAllVecTimestamp.Broadcast(Context, Args.T); + OnDeleteAllUniqueUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::DeleteAllVecU128(const TArray& N) +void URemoteReducers::DeleteAllVecBool(const TArray& B) { if (!Conn) { @@ -4356,45 +4424,45 @@ void URemoteReducers::DeleteAllVecU128(const TArray& N) return; } - FDeleteAllVecU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU128(ReducerArgs)); } + FDeleteAllVecBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU128(const FReducerEventContext& Context, const UDeleteAllVecU128Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecBool(const FReducerEventContext& Context, const UDeleteAllVecBoolReducer* Args) { - if (!OnDeleteAllVecU128.IsBound()) + if (!OnDeleteAllVecBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); } return false; } - OnDeleteAllVecU128.Broadcast(Context, Args->N); + OnDeleteAllVecBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeDeleteAllVecU128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU128Args& Args) +bool URemoteReducers::InvokeDeleteAllVecBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllVecBoolArgs& Args) { - if (!OnDeleteAllVecU128.IsBound()) + if (!OnDeleteAllVecBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecBool")); } return false; } - OnDeleteAllVecU128.Broadcast(Context, Args.N); + OnDeleteAllVecBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::DeleteAllVecU16(const TArray& N) +void URemoteReducers::DeleteAllVecByteStruct(const TArray& S) { if (!Conn) { @@ -4402,45 +4470,45 @@ void URemoteReducers::DeleteAllVecU16(const TArray& N) return; } - FDeleteAllVecU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU16(ReducerArgs)); } + FDeleteAllVecByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU16(const FReducerEventContext& Context, const UDeleteAllVecU16Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecByteStruct(const FReducerEventContext& Context, const UDeleteAllVecByteStructReducer* Args) { - if (!OnDeleteAllVecU16.IsBound()) + if (!OnDeleteAllVecByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); } return false; } - OnDeleteAllVecU16.Broadcast(Context, Args->N); + OnDeleteAllVecByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU16Args& Args) +bool URemoteReducers::InvokeDeleteAllVecByteStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecByteStructArgs& Args) { - if (!OnDeleteAllVecU16.IsBound()) + if (!OnDeleteAllVecByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecByteStruct")); } return false; } - OnDeleteAllVecU16.Broadcast(Context, Args.N); + OnDeleteAllVecByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteAllVecU256(const TArray& N) +void URemoteReducers::DeleteAllVecEnumWithPayload(const TArray& E) { if (!Conn) { @@ -4448,45 +4516,45 @@ void URemoteReducers::DeleteAllVecU256(const TArray& N) return; } - FDeleteAllVecU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU256(ReducerArgs)); } + FDeleteAllVecEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU256(const FReducerEventContext& Context, const UDeleteAllVecU256Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEnumWithPayload(const FReducerEventContext& Context, const UDeleteAllVecEnumWithPayloadReducer* Args) { - if (!OnDeleteAllVecU256.IsBound()) + if (!OnDeleteAllVecEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); } return false; } - OnDeleteAllVecU256.Broadcast(Context, Args->N); + OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteAllVecU256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU256Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEnumWithPayloadArgs& Args) { - if (!OnDeleteAllVecU256.IsBound()) + if (!OnDeleteAllVecEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEnumWithPayload")); } return false; } - OnDeleteAllVecU256.Broadcast(Context, Args.N); + OnDeleteAllVecEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteAllVecU32(const TArray& N) +void URemoteReducers::DeleteAllVecEveryPrimitiveStruct(const TArray& S) { if (!Conn) { @@ -4494,45 +4562,45 @@ void URemoteReducers::DeleteAllVecU32(const TArray& N) return; } - FDeleteAllVecU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU32(ReducerArgs)); } + FDeleteAllVecEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU32(const FReducerEventContext& Context, const UDeleteAllVecU32Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryPrimitiveStructReducer* Args) { - if (!OnDeleteAllVecU32.IsBound()) + if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); } return false; } - OnDeleteAllVecU32.Broadcast(Context, Args->N); + OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU32Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryPrimitiveStructArgs& Args) { - if (!OnDeleteAllVecU32.IsBound()) + if (!OnDeleteAllVecEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryPrimitiveStruct")); } return false; } - OnDeleteAllVecU32.Broadcast(Context, Args.N); + OnDeleteAllVecEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteAllVecU64(const TArray& N) +void URemoteReducers::DeleteAllVecEveryVecStruct(const TArray& S) { if (!Conn) { @@ -4540,32 +4608,814 @@ void URemoteReducers::DeleteAllVecU64(const TArray& N) return; } - FDeleteAllVecU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU64(ReducerArgs)); } + FDeleteAllVecEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU64(const FReducerEventContext& Context, const UDeleteAllVecU64Reducer* Args) +bool URemoteReducers::InvokeDeleteAllVecEveryVecStruct(const FReducerEventContext& Context, const UDeleteAllVecEveryVecStructReducer* Args) { - if (!OnDeleteAllVecU64.IsBound()) + if (!OnDeleteAllVecEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); } return false; } - OnDeleteAllVecU64.Broadcast(Context, Args->N); + OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU64Args& Args) +bool URemoteReducers::InvokeDeleteAllVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecEveryVecStructArgs& Args) { - if (!OnDeleteAllVecU64.IsBound()) + if (!OnDeleteAllVecEveryVecStruct.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecEveryVecStruct")); + } + return false; + } + + OnDeleteAllVecEveryVecStruct.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecF32(const TArray& F) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecF32(const FReducerEventContext& Context, const UDeleteAllVecF32Reducer* Args) +{ + if (!OnDeleteAllVecF32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + } + return false; + } + + OnDeleteAllVecF32.Broadcast(Context, Args->F); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecF32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF32Args& Args) +{ + if (!OnDeleteAllVecF32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF32")); + } + return false; + } + + OnDeleteAllVecF32.Broadcast(Context, Args.F); + return true; +} + +void URemoteReducers::DeleteAllVecF64(const TArray& F) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecF64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecF64(const FReducerEventContext& Context, const UDeleteAllVecF64Reducer* Args) +{ + if (!OnDeleteAllVecF64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + } + return false; + } + + OnDeleteAllVecF64.Broadcast(Context, Args->F); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecF64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecF64Args& Args) +{ + if (!OnDeleteAllVecF64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecF64")); + } + return false; + } + + OnDeleteAllVecF64.Broadcast(Context, Args.F); + return true; +} + +void URemoteReducers::DeleteAllVecI128(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI128(const FReducerEventContext& Context, const UDeleteAllVecI128Reducer* Args) +{ + if (!OnDeleteAllVecI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + } + return false; + } + + OnDeleteAllVecI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI128Args& Args) +{ + if (!OnDeleteAllVecI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI128")); + } + return false; + } + + OnDeleteAllVecI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI16(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI16(const FReducerEventContext& Context, const UDeleteAllVecI16Reducer* Args) +{ + if (!OnDeleteAllVecI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + } + return false; + } + + OnDeleteAllVecI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI16Args& Args) +{ + if (!OnDeleteAllVecI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI16")); + } + return false; + } + + OnDeleteAllVecI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI256(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI256(const FReducerEventContext& Context, const UDeleteAllVecI256Reducer* Args) +{ + if (!OnDeleteAllVecI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + } + return false; + } + + OnDeleteAllVecI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI256Args& Args) +{ + if (!OnDeleteAllVecI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI256")); + } + return false; + } + + OnDeleteAllVecI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI32(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI32(const FReducerEventContext& Context, const UDeleteAllVecI32Reducer* Args) +{ + if (!OnDeleteAllVecI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + } + return false; + } + + OnDeleteAllVecI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI32Args& Args) +{ + if (!OnDeleteAllVecI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI32")); + } + return false; + } + + OnDeleteAllVecI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI64(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI64(const FReducerEventContext& Context, const UDeleteAllVecI64Reducer* Args) +{ + if (!OnDeleteAllVecI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + } + return false; + } + + OnDeleteAllVecI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI64Args& Args) +{ + if (!OnDeleteAllVecI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI64")); + } + return false; + } + + OnDeleteAllVecI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecI8(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecI8(const FReducerEventContext& Context, const UDeleteAllVecI8Reducer* Args) +{ + if (!OnDeleteAllVecI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + } + return false; + } + + OnDeleteAllVecI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecI8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecI8Args& Args) +{ + if (!OnDeleteAllVecI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecI8")); + } + return false; + } + + OnDeleteAllVecI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecIdentity(const TArray& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecIdentity(const FReducerEventContext& Context, const UDeleteAllVecIdentityReducer* Args) +{ + if (!OnDeleteAllVecIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + } + return false; + } + + OnDeleteAllVecIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllVecIdentityArgs& Args) +{ + if (!OnDeleteAllVecIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecIdentity")); + } + return false; + } + + OnDeleteAllVecIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteAllVecSimpleEnum(const TArray& E) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecSimpleEnum(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecSimpleEnum(const FReducerEventContext& Context, const UDeleteAllVecSimpleEnumReducer* Args) +{ + if (!OnDeleteAllVecSimpleEnum.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + } + return false; + } + + OnDeleteAllVecSimpleEnum.Broadcast(Context, Args->E); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FDeleteAllVecSimpleEnumArgs& Args) +{ + if (!OnDeleteAllVecSimpleEnum.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecSimpleEnum")); + } + return false; + } + + OnDeleteAllVecSimpleEnum.Broadcast(Context, Args.E); + return true; +} + +void URemoteReducers::DeleteAllVecString(const TArray& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecString(const FReducerEventContext& Context, const UDeleteAllVecStringReducer* Args) +{ + if (!OnDeleteAllVecString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + } + return false; + } + + OnDeleteAllVecString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecStringWithArgs(const FReducerEventContext& Context, const FDeleteAllVecStringArgs& Args) +{ + if (!OnDeleteAllVecString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecString")); + } + return false; + } + + OnDeleteAllVecString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecTimestamp(const TArray& T) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecTimestamp(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecTimestamp(const FReducerEventContext& Context, const UDeleteAllVecTimestampReducer* Args) +{ + if (!OnDeleteAllVecTimestamp.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + } + return false; + } + + OnDeleteAllVecTimestamp.Broadcast(Context, Args->T); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecTimestampWithArgs(const FReducerEventContext& Context, const FDeleteAllVecTimestampArgs& Args) +{ + if (!OnDeleteAllVecTimestamp.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecTimestamp")); + } + return false; + } + + OnDeleteAllVecTimestamp.Broadcast(Context, Args.T); + return true; +} + +void URemoteReducers::DeleteAllVecU128(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU128(const FReducerEventContext& Context, const UDeleteAllVecU128Reducer* Args) +{ + if (!OnDeleteAllVecU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + } + return false; + } + + OnDeleteAllVecU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU128WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU128Args& Args) +{ + if (!OnDeleteAllVecU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU128")); + } + return false; + } + + OnDeleteAllVecU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU16(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU16(const FReducerEventContext& Context, const UDeleteAllVecU16Reducer* Args) +{ + if (!OnDeleteAllVecU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + } + return false; + } + + OnDeleteAllVecU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU16WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU16Args& Args) +{ + if (!OnDeleteAllVecU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU16")); + } + return false; + } + + OnDeleteAllVecU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU256(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU256(const FReducerEventContext& Context, const UDeleteAllVecU256Reducer* Args) +{ + if (!OnDeleteAllVecU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + } + return false; + } + + OnDeleteAllVecU256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU256WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU256Args& Args) +{ + if (!OnDeleteAllVecU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU256")); + } + return false; + } + + OnDeleteAllVecU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU32(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU32(const FReducerEventContext& Context, const UDeleteAllVecU32Reducer* Args) +{ + if (!OnDeleteAllVecU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + } + return false; + } + + OnDeleteAllVecU32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU32WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU32Args& Args) +{ + if (!OnDeleteAllVecU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU32")); + } + return false; + } + + OnDeleteAllVecU32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU64(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU64(const FReducerEventContext& Context, const UDeleteAllVecU64Reducer* Args) +{ + if (!OnDeleteAllVecU64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU64")); + } + return false; + } + + OnDeleteAllVecU64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU64Args& Args) +{ + if (!OnDeleteAllVecU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { @@ -4574,11 +5424,2150 @@ bool URemoteReducers::InvokeDeleteAllVecU64WithArgs(const FReducerEventContext& return false; } - OnDeleteAllVecU64.Broadcast(Context, Args.N); + OnDeleteAllVecU64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecU8(const TArray& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecU8(const FReducerEventContext& Context, const UDeleteAllVecU8Reducer* Args) +{ + if (!OnDeleteAllVecU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + } + return false; + } + + OnDeleteAllVecU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecU8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU8Args& Args) +{ + if (!OnDeleteAllVecU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + } + return false; + } + + OnDeleteAllVecU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUnitStruct(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecUnitStruct(const FReducerEventContext& Context, const UDeleteAllVecUnitStructReducer* Args) +{ + if (!OnDeleteAllVecUnitStruct.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + } + return false; + } + + OnDeleteAllVecUnitStruct.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecUnitStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUnitStructArgs& Args) +{ + if (!OnDeleteAllVecUnitStruct.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + } + return false; + } + + OnDeleteAllVecUnitStruct.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteAllVecUuid(const TArray& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteAllVecUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteAllVecUuid(const FReducerEventContext& Context, const UDeleteAllVecUuidReducer* Args) +{ + if (!OnDeleteAllVecUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + } + return false; + } + + OnDeleteAllVecUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeleteAllVecUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUuidArgs& Args) +{ + if (!OnDeleteAllVecUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + } + return false; + } + + OnDeleteAllVecUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteFromBtreeU32Args ReducerArgs(Rows); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_from_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteFromBtreeU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteFromBtreeU32(const FReducerEventContext& Context, const UDeleteFromBtreeU32Reducer* Args) +{ + if (!OnDeleteFromBtreeU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + } + return false; + } + + OnDeleteFromBtreeU32.Broadcast(Context, Args->Rows); + return true; +} + +bool URemoteReducers::InvokeDeleteFromBtreeU32WithArgs(const FReducerEventContext& Context, const FDeleteFromBtreeU32Args& Args) +{ + if (!OnDeleteFromBtreeU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + } + return false; + } + + OnDeleteFromBtreeU32.Broadcast(Context, Args.Rows); + return true; +} + +void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_large_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteLargeTable(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteLargeTable(const FReducerEventContext& Context, const UDeleteLargeTableReducer* Args) +{ + if (!OnDeleteLargeTable.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + } + return false; + } + + FDeleteLargeTableArgs ArgsStruct; + ArgsStruct.A = Args->A; + ArgsStruct.B = Args->B; + ArgsStruct.C = Args->C; + ArgsStruct.D = Args->D; + ArgsStruct.E = Args->E; + ArgsStruct.F = Args->F; + ArgsStruct.G = Args->G; + ArgsStruct.H = Args->H; + ArgsStruct.I = Args->I; + ArgsStruct.J = Args->J; + ArgsStruct.K = Args->K; + ArgsStruct.L = Args->L; + ArgsStruct.M = Args->M; + ArgsStruct.N = Args->N; + ArgsStruct.O = Args->O; + ArgsStruct.P = Args->P; + ArgsStruct.Q = Args->Q; + ArgsStruct.R = Args->R; + ArgsStruct.S = Args->S; + ArgsStruct.T = Args->T; + ArgsStruct.U = Args->U; + ArgsStruct.V = Args->V; + OnDeleteLargeTable.Broadcast(Context, ArgsStruct); + return true; +} + +bool URemoteReducers::InvokeDeleteLargeTableWithArgs(const FReducerEventContext& Context, const FDeleteLargeTableArgs& Args) +{ + if (!OnDeleteLargeTable.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + } + return false; + } + + OnDeleteLargeTable.Broadcast(Context, Args); + return true; +} + +void URemoteReducers::DeletePkBool(const bool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkBool(const FReducerEventContext& Context, const UDeletePkBoolReducer* Args) +{ + if (!OnDeletePkBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + } + return false; + } + + OnDeletePkBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeletePkBoolWithArgs(const FReducerEventContext& Context, const FDeletePkBoolArgs& Args) +{ + if (!OnDeletePkBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + } + return false; + } + + OnDeletePkBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkConnectionId(const FReducerEventContext& Context, const UDeletePkConnectionIdReducer* Args) +{ + if (!OnDeletePkConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + } + return false; + } + + OnDeletePkConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeletePkConnectionIdWithArgs(const FReducerEventContext& Context, const FDeletePkConnectionIdArgs& Args) +{ + if (!OnDeletePkConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + } + return false; + } + + OnDeletePkConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI128(const FReducerEventContext& Context, const UDeletePkI128Reducer* Args) +{ + if (!OnDeletePkI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + } + return false; + } + + OnDeletePkI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI128WithArgs(const FReducerEventContext& Context, const FDeletePkI128Args& Args) +{ + if (!OnDeletePkI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + } + return false; + } + + OnDeletePkI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI16(const int16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI16(const FReducerEventContext& Context, const UDeletePkI16Reducer* Args) +{ + if (!OnDeletePkI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + } + return false; + } + + OnDeletePkI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI16WithArgs(const FReducerEventContext& Context, const FDeletePkI16Args& Args) +{ + if (!OnDeletePkI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + } + return false; + } + + OnDeletePkI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI256(const FReducerEventContext& Context, const UDeletePkI256Reducer* Args) +{ + if (!OnDeletePkI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + } + return false; + } + + OnDeletePkI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI256WithArgs(const FReducerEventContext& Context, const FDeletePkI256Args& Args) +{ + if (!OnDeletePkI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + } + return false; + } + + OnDeletePkI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI32(const int32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI32(const FReducerEventContext& Context, const UDeletePkI32Reducer* Args) +{ + if (!OnDeletePkI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + } + return false; + } + + OnDeletePkI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI32WithArgs(const FReducerEventContext& Context, const FDeletePkI32Args& Args) +{ + if (!OnDeletePkI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + } + return false; + } + + OnDeletePkI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI64(const int64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI64(const FReducerEventContext& Context, const UDeletePkI64Reducer* Args) +{ + if (!OnDeletePkI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + } + return false; + } + + OnDeletePkI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI64WithArgs(const FReducerEventContext& Context, const FDeletePkI64Args& Args) +{ + if (!OnDeletePkI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + } + return false; + } + + OnDeletePkI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkI8(const int8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkI8(const FReducerEventContext& Context, const UDeletePkI8Reducer* Args) +{ + if (!OnDeletePkI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + } + return false; + } + + OnDeletePkI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkI8WithArgs(const FReducerEventContext& Context, const FDeletePkI8Args& Args) +{ + if (!OnDeletePkI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + } + return false; + } + + OnDeletePkI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkIdentity(const FReducerEventContext& Context, const UDeletePkIdentityReducer* Args) +{ + if (!OnDeletePkIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + } + return false; + } + + OnDeletePkIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeletePkIdentityWithArgs(const FReducerEventContext& Context, const FDeletePkIdentityArgs& Args) +{ + if (!OnDeletePkIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + } + return false; + } + + OnDeletePkIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeletePkString(const FString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkString(const FReducerEventContext& Context, const UDeletePkStringReducer* Args) +{ + if (!OnDeletePkString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + } + return false; + } + + OnDeletePkString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeletePkStringWithArgs(const FReducerEventContext& Context, const FDeletePkStringArgs& Args) +{ + if (!OnDeletePkString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + } + return false; + } + + OnDeletePkString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU128(const FReducerEventContext& Context, const UDeletePkU128Reducer* Args) +{ + if (!OnDeletePkU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + } + return false; + } + + OnDeletePkU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU128WithArgs(const FReducerEventContext& Context, const FDeletePkU128Args& Args) +{ + if (!OnDeletePkU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + } + return false; + } + + OnDeletePkU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU16(const uint16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU16(const FReducerEventContext& Context, const UDeletePkU16Reducer* Args) +{ + if (!OnDeletePkU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + } + return false; + } + + OnDeletePkU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU16WithArgs(const FReducerEventContext& Context, const FDeletePkU16Args& Args) +{ + if (!OnDeletePkU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + } + return false; + } + + OnDeletePkU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU256(const FReducerEventContext& Context, const UDeletePkU256Reducer* Args) +{ + if (!OnDeletePkU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + } + return false; + } + + OnDeletePkU256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU256WithArgs(const FReducerEventContext& Context, const FDeletePkU256Args& Args) +{ + if (!OnDeletePkU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + } + return false; + } + + OnDeletePkU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU32(const uint32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32(const FReducerEventContext& Context, const UDeletePkU32Reducer* Args) +{ + if (!OnDeletePkU32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + } + return false; + } + + OnDeletePkU32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32WithArgs(const FReducerEventContext& Context, const FDeletePkU32Args& Args) +{ + if (!OnDeletePkU32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + } + return false; + } + + OnDeletePkU32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32InsertPkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_insert_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32InsertPkU32Two(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32InsertPkU32Two(const FReducerEventContext& Context, const UDeletePkU32InsertPkU32TwoReducer* Args) +{ + if (!OnDeletePkU32InsertPkU32Two.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + } + return false; + } + + OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32InsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32InsertPkU32TwoArgs& Args) +{ + if (!OnDeletePkU32InsertPkU32Two.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + } + return false; + } + + OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + return true; +} + +void URemoteReducers::DeletePkU32Two(const uint32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU32TwoArgs ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32Two(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU32Two(const FReducerEventContext& Context, const UDeletePkU32TwoReducer* Args) +{ + if (!OnDeletePkU32Two.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + } + return false; + } + + OnDeletePkU32Two.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32TwoArgs& Args) +{ + if (!OnDeletePkU32Two.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + } + return false; + } + + OnDeletePkU32Two.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU64(const uint64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU64(const FReducerEventContext& Context, const UDeletePkU64Reducer* Args) +{ + if (!OnDeletePkU64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + } + return false; + } + + OnDeletePkU64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU64WithArgs(const FReducerEventContext& Context, const FDeletePkU64Args& Args) +{ + if (!OnDeletePkU64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + } + return false; + } + + OnDeletePkU64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkU8(const uint8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkU8(const FReducerEventContext& Context, const UDeletePkU8Reducer* Args) +{ + if (!OnDeletePkU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + } + return false; + } + + OnDeletePkU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeletePkU8WithArgs(const FReducerEventContext& Context, const FDeletePkU8Args& Args) +{ + if (!OnDeletePkU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + } + return false; + } + + OnDeletePkU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeletePkUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeletePkUuid(const FReducerEventContext& Context, const UDeletePkUuidReducer* Args) +{ + if (!OnDeletePkUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + } + return false; + } + + OnDeletePkUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeletePkUuidWithArgs(const FReducerEventContext& Context, const FDeletePkUuidArgs& Args) +{ + if (!OnDeletePkUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + } + return false; + } + + OnDeletePkUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteUniqueBool(const bool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueBool(const FReducerEventContext& Context, const UDeleteUniqueBoolReducer* Args) +{ + if (!OnDeleteUniqueBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + } + return false; + } + + OnDeleteUniqueBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueBoolArgs& Args) +{ + if (!OnDeleteUniqueBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + } + return false; + } + + OnDeleteUniqueBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueConnectionId(const FReducerEventContext& Context, const UDeleteUniqueConnectionIdReducer* Args) +{ + if (!OnDeleteUniqueConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + } + return false; + } + + OnDeleteUniqueConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueConnectionIdArgs& Args) +{ + if (!OnDeleteUniqueConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + } + return false; + } + + OnDeleteUniqueConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI128(const FReducerEventContext& Context, const UDeleteUniqueI128Reducer* Args) +{ + if (!OnDeleteUniqueI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + } + return false; + } + + OnDeleteUniqueI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI128Args& Args) +{ + if (!OnDeleteUniqueI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + } + return false; + } + + OnDeleteUniqueI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI16(const int16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI16(const FReducerEventContext& Context, const UDeleteUniqueI16Reducer* Args) +{ + if (!OnDeleteUniqueI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + } + return false; + } + + OnDeleteUniqueI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI16Args& Args) +{ + if (!OnDeleteUniqueI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + } + return false; + } + + OnDeleteUniqueI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI256(const FReducerEventContext& Context, const UDeleteUniqueI256Reducer* Args) +{ + if (!OnDeleteUniqueI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + } + return false; + } + + OnDeleteUniqueI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI256Args& Args) +{ + if (!OnDeleteUniqueI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + } + return false; + } + + OnDeleteUniqueI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI32(const int32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI32(const FReducerEventContext& Context, const UDeleteUniqueI32Reducer* Args) +{ + if (!OnDeleteUniqueI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + } + return false; + } + + OnDeleteUniqueI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI32Args& Args) +{ + if (!OnDeleteUniqueI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + } + return false; + } + + OnDeleteUniqueI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI64(const int64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI64(const FReducerEventContext& Context, const UDeleteUniqueI64Reducer* Args) +{ + if (!OnDeleteUniqueI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + } + return false; + } + + OnDeleteUniqueI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI64Args& Args) +{ + if (!OnDeleteUniqueI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + } + return false; + } + + OnDeleteUniqueI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueI8(const int8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueI8(const FReducerEventContext& Context, const UDeleteUniqueI8Reducer* Args) +{ + if (!OnDeleteUniqueI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + } + return false; + } + + OnDeleteUniqueI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI8Args& Args) +{ + if (!OnDeleteUniqueI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + } + return false; + } + + OnDeleteUniqueI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueIdentity(const FReducerEventContext& Context, const UDeleteUniqueIdentityReducer* Args) +{ + if (!OnDeleteUniqueIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + } + return false; + } + + OnDeleteUniqueIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args) +{ + if (!OnDeleteUniqueIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + } + return false; + } + + OnDeleteUniqueIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteUniqueOptionBool(const FTestClientOptionalBool B) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionBool(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionBool(const FReducerEventContext& Context, const UDeleteUniqueOptionBoolReducer* Args) +{ + if (!OnDeleteUniqueOptionBool.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionBool")); + } + return false; + } + + OnDeleteUniqueOptionBool.Broadcast(Context, Args->B); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionBoolArgs& Args) +{ + if (!OnDeleteUniqueOptionBool.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionBool")); + } + return false; + } + + OnDeleteUniqueOptionBool.Broadcast(Context, Args.B); + return true; +} + +void URemoteReducers::DeleteUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionConnectionId(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteUniqueOptionConnectionIdReducer* Args) +{ + if (!OnDeleteUniqueOptionConnectionId.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionConnectionId")); + } + return false; + } + + OnDeleteUniqueOptionConnectionId.Broadcast(Context, Args->A); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionConnectionIdArgs& Args) +{ + if (!OnDeleteUniqueOptionConnectionId.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionConnectionId")); + } + return false; + } + + OnDeleteUniqueOptionConnectionId.Broadcast(Context, Args.A); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI128(const FTestClientOptionalInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI128(const FReducerEventContext& Context, const UDeleteUniqueOptionI128Reducer* Args) +{ + if (!OnDeleteUniqueOptionI128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI128")); + } + return false; + } + + OnDeleteUniqueOptionI128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI128Args& Args) +{ + if (!OnDeleteUniqueOptionI128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI128")); + } + return false; + } + + OnDeleteUniqueOptionI128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI16(const FTestClientOptionalInt16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI16(const FReducerEventContext& Context, const UDeleteUniqueOptionI16Reducer* Args) +{ + if (!OnDeleteUniqueOptionI16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI16")); + } + return false; + } + + OnDeleteUniqueOptionI16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI16Args& Args) +{ + if (!OnDeleteUniqueOptionI16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI16")); + } + return false; + } + + OnDeleteUniqueOptionI16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI256(const FTestClientOptionalInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI256(const FReducerEventContext& Context, const UDeleteUniqueOptionI256Reducer* Args) +{ + if (!OnDeleteUniqueOptionI256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI256")); + } + return false; + } + + OnDeleteUniqueOptionI256.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI256Args& Args) +{ + if (!OnDeleteUniqueOptionI256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI256")); + } + return false; + } + + OnDeleteUniqueOptionI256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI32(const FTestClientOptionalInt32 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI32(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI32(const FReducerEventContext& Context, const UDeleteUniqueOptionI32Reducer* Args) +{ + if (!OnDeleteUniqueOptionI32.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI32")); + } + return false; + } + + OnDeleteUniqueOptionI32.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI32Args& Args) +{ + if (!OnDeleteUniqueOptionI32.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI32")); + } + return false; + } + + OnDeleteUniqueOptionI32.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI64(const FTestClientOptionalInt64 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI64(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI64(const FReducerEventContext& Context, const UDeleteUniqueOptionI64Reducer* Args) +{ + if (!OnDeleteUniqueOptionI64.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI64")); + } + return false; + } + + OnDeleteUniqueOptionI64.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI64Args& Args) +{ + if (!OnDeleteUniqueOptionI64.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI64")); + } + return false; + } + + OnDeleteUniqueOptionI64.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionI8(const FTestClientOptionalInt8 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionI8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI8(const FReducerEventContext& Context, const UDeleteUniqueOptionI8Reducer* Args) +{ + if (!OnDeleteUniqueOptionI8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI8")); + } + return false; + } + + OnDeleteUniqueOptionI8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI8Args& Args) +{ + if (!OnDeleteUniqueOptionI8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionI8")); + } + return false; + } + + OnDeleteUniqueOptionI8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionIdentity(const FTestClientOptionalIdentity& I) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionIdentity(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteUniqueOptionIdentityReducer* Args) +{ + if (!OnDeleteUniqueOptionIdentity.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionIdentity")); + } + return false; + } + + OnDeleteUniqueOptionIdentity.Broadcast(Context, Args->I); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionIdentityArgs& Args) +{ + if (!OnDeleteUniqueOptionIdentity.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionIdentity")); + } + return false; + } + + OnDeleteUniqueOptionIdentity.Broadcast(Context, Args.I); + return true; +} + +void URemoteReducers::DeleteUniqueOptionString(const FTestClientOptionalString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionString(const FReducerEventContext& Context, const UDeleteUniqueOptionStringReducer* Args) +{ + if (!OnDeleteUniqueOptionString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionString")); + } + return false; + } + + OnDeleteUniqueOptionString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionStringArgs& Args) +{ + if (!OnDeleteUniqueOptionString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionString")); + } + return false; + } + + OnDeleteUniqueOptionString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU128(const FTestClientOptionalUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU128(const FReducerEventContext& Context, const UDeleteUniqueOptionU128Reducer* Args) +{ + if (!OnDeleteUniqueOptionU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU128")); + } + return false; + } + + OnDeleteUniqueOptionU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU128Args& Args) +{ + if (!OnDeleteUniqueOptionU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU128")); + } + return false; + } + + OnDeleteUniqueOptionU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU16(const FTestClientOptionalUInt16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU16(const FReducerEventContext& Context, const UDeleteUniqueOptionU16Reducer* Args) +{ + if (!OnDeleteUniqueOptionU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU16")); + } + return false; + } + + OnDeleteUniqueOptionU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU16Args& Args) +{ + if (!OnDeleteUniqueOptionU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU16")); + } + return false; + } + + OnDeleteUniqueOptionU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU256(const FTestClientOptionalUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU256(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU256(const FReducerEventContext& Context, const UDeleteUniqueOptionU256Reducer* Args) +{ + if (!OnDeleteUniqueOptionU256.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU256")); + } + return false; + } + + OnDeleteUniqueOptionU256.Broadcast(Context, Args->N); return true; } -void URemoteReducers::DeleteAllVecU8(const TArray& N) +bool URemoteReducers::InvokeDeleteUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU256Args& Args) +{ + if (!OnDeleteUniqueOptionU256.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU256")); + } + return false; + } + + OnDeleteUniqueOptionU256.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionU32(const FTestClientOptionalUInt32 N) { if (!Conn) { @@ -4586,45 +7575,45 @@ void URemoteReducers::DeleteAllVecU8(const TArray& N) return; } - FDeleteAllVecU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecU8(ReducerArgs)); } + FDeleteUniqueOptionU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecU8(const FReducerEventContext& Context, const UDeleteAllVecU8Reducer* Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU32(const FReducerEventContext& Context, const UDeleteUniqueOptionU32Reducer* Args) { - if (!OnDeleteAllVecU8.IsBound()) + if (!OnDeleteUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU32")); } return false; } - OnDeleteAllVecU8.Broadcast(Context, Args->N); + OnDeleteUniqueOptionU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecU8WithArgs(const FReducerEventContext& Context, const FDeleteAllVecU8Args& Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU32Args& Args) { - if (!OnDeleteAllVecU8.IsBound()) + if (!OnDeleteUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU32")); } return false; } - OnDeleteAllVecU8.Broadcast(Context, Args.N); + OnDeleteUniqueOptionU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) +void URemoteReducers::DeleteUniqueOptionU64(const FTestClientOptionalUInt64 N) { if (!Conn) { @@ -4632,45 +7621,45 @@ void URemoteReducers::DeleteAllVecUnitStruct(const TArray& S) return; } - FDeleteAllVecUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUnitStruct(ReducerArgs)); } + FDeleteUniqueOptionU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecUnitStruct(const FReducerEventContext& Context, const UDeleteAllVecUnitStructReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU64(const FReducerEventContext& Context, const UDeleteUniqueOptionU64Reducer* Args) { - if (!OnDeleteAllVecUnitStruct.IsBound()) + if (!OnDeleteUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU64")); } return false; } - OnDeleteAllVecUnitStruct.Broadcast(Context, Args->S); + OnDeleteUniqueOptionU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecUnitStructWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUnitStructArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU64Args& Args) { - if (!OnDeleteAllVecUnitStruct.IsBound()) + if (!OnDeleteUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU64")); } return false; } - OnDeleteAllVecUnitStruct.Broadcast(Context, Args.S); + OnDeleteUniqueOptionU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteAllVecUuid(const TArray& U) +void URemoteReducers::DeleteUniqueOptionU8(const FTestClientOptionalUInt8 N) { if (!Conn) { @@ -4678,45 +7667,275 @@ void URemoteReducers::DeleteAllVecUuid(const TArray& U) return; } - FDeleteAllVecUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_all_vec_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteAllVecUuid(ReducerArgs)); } + FDeleteUniqueOptionU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionU8(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU8(const FReducerEventContext& Context, const UDeleteUniqueOptionU8Reducer* Args) +{ + if (!OnDeleteUniqueOptionU8.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU8")); + } + return false; + } + + OnDeleteUniqueOptionU8.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU8Args& Args) +{ + if (!OnDeleteUniqueOptionU8.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionU8")); + } + return false; + } + + OnDeleteUniqueOptionU8.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueOptionUuid(const FTestClientOptionalUuid& U) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueOptionUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueOptionUuid(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteUniqueOptionUuidReducer* Args) +{ + if (!OnDeleteUniqueOptionUuid.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionUuid")); + } + return false; + } + + OnDeleteUniqueOptionUuid.Broadcast(Context, Args->U); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionUuidArgs& Args) +{ + if (!OnDeleteUniqueOptionUuid.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueOptionUuid")); + } + return false; + } + + OnDeleteUniqueOptionUuid.Broadcast(Context, Args.U); + return true; +} + +void URemoteReducers::DeleteUniqueString(const FString& S) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueString(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args) +{ + if (!OnDeleteUniqueString.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + } + return false; + } + + OnDeleteUniqueString.Broadcast(Context, Args->S); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args) +{ + if (!OnDeleteUniqueString.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + } + return false; + } + + OnDeleteUniqueString.Broadcast(Context, Args.S); + return true; +} + +void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU128(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args) +{ + if (!OnDeleteUniqueU128.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + } + return false; + } + + OnDeleteUniqueU128.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args) +{ + if (!OnDeleteUniqueU128.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + } + return false; + } + + OnDeleteUniqueU128.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueU16(const uint16 N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU16(ReducerArgs)); } +} + +bool URemoteReducers::InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args) +{ + if (!OnDeleteUniqueU16.IsBound()) + { + // Handle unhandled reducer error + if (InternalOnUnhandledReducerError.IsBound()) + { + // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases + // For now, just broadcast any error + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + } + return false; + } + + OnDeleteUniqueU16.Broadcast(Context, Args->N); + return true; +} + +bool URemoteReducers::InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args) +{ + if (!OnDeleteUniqueU16.IsBound()) + { + if (InternalOnUnhandledReducerError.IsBound()) + { + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + } + return false; + } + + OnDeleteUniqueU16.Broadcast(Context, Args.N); + return true; +} + +void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) +{ + if (!Conn) + { + UE_LOG(LogTemp, Error, TEXT("SpacetimeDB connection is null")); + return; + } + + FDeleteUniqueU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteAllVecUuid(const FReducerEventContext& Context, const UDeleteAllVecUuidReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args) { - if (!OnDeleteAllVecUuid.IsBound()) + if (!OnDeleteUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); } return false; } - OnDeleteAllVecUuid.Broadcast(Context, Args->U); + OnDeleteUniqueU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteAllVecUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllVecUuidArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args) { - if (!OnDeleteAllVecUuid.IsBound()) + if (!OnDeleteUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteAllVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); } return false; } - OnDeleteAllVecUuid.Broadcast(Context, Args.U); + OnDeleteUniqueU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) +void URemoteReducers::DeleteUniqueU32(const uint32 N) { if (!Conn) { @@ -4724,45 +7943,45 @@ void URemoteReducers::DeleteFromBtreeU32(const TArray& Rows) return; } - FDeleteFromBtreeU32Args ReducerArgs(Rows); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_from_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteFromBtreeU32(ReducerArgs)); } + FDeleteUniqueU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteFromBtreeU32(const FReducerEventContext& Context, const UDeleteFromBtreeU32Reducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args) { - if (!OnDeleteFromBtreeU32.IsBound()) + if (!OnDeleteUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); } return false; } - OnDeleteFromBtreeU32.Broadcast(Context, Args->Rows); + OnDeleteUniqueU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteFromBtreeU32WithArgs(const FReducerEventContext& Context, const FDeleteFromBtreeU32Args& Args) +bool URemoteReducers::InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args) { - if (!OnDeleteFromBtreeU32.IsBound()) + if (!OnDeleteUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteFromBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); } return false; } - OnDeleteFromBtreeU32.Broadcast(Context, Args.Rows); + OnDeleteUniqueU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +void URemoteReducers::DeleteUniqueU64(const uint64 N) { if (!Conn) { @@ -4770,68 +7989,45 @@ void URemoteReducers::DeleteLargeTable(const uint8 A, const uint16 B, const uint return; } - FDeleteLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_large_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteLargeTable(ReducerArgs)); } + FDeleteUniqueU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteLargeTable(const FReducerEventContext& Context, const UDeleteLargeTableReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args) { - if (!OnDeleteLargeTable.IsBound()) + if (!OnDeleteUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); } return false; } - FDeleteLargeTableArgs ArgsStruct; - ArgsStruct.A = Args->A; - ArgsStruct.B = Args->B; - ArgsStruct.C = Args->C; - ArgsStruct.D = Args->D; - ArgsStruct.E = Args->E; - ArgsStruct.F = Args->F; - ArgsStruct.G = Args->G; - ArgsStruct.H = Args->H; - ArgsStruct.I = Args->I; - ArgsStruct.J = Args->J; - ArgsStruct.K = Args->K; - ArgsStruct.L = Args->L; - ArgsStruct.M = Args->M; - ArgsStruct.N = Args->N; - ArgsStruct.O = Args->O; - ArgsStruct.P = Args->P; - ArgsStruct.Q = Args->Q; - ArgsStruct.R = Args->R; - ArgsStruct.S = Args->S; - ArgsStruct.T = Args->T; - ArgsStruct.U = Args->U; - ArgsStruct.V = Args->V; - OnDeleteLargeTable.Broadcast(Context, ArgsStruct); + OnDeleteUniqueU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteLargeTableWithArgs(const FReducerEventContext& Context, const FDeleteLargeTableArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args) { - if (!OnDeleteLargeTable.IsBound()) + if (!OnDeleteUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); } return false; } - OnDeleteLargeTable.Broadcast(Context, Args); + OnDeleteUniqueU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkBool(const bool B) +void URemoteReducers::DeleteUniqueU8(const uint8 N) { if (!Conn) { @@ -4839,45 +8035,45 @@ void URemoteReducers::DeletePkBool(const bool B) return; } - FDeletePkBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkBool(ReducerArgs)); } + FDeleteUniqueU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkBool(const FReducerEventContext& Context, const UDeletePkBoolReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args) { - if (!OnDeletePkBool.IsBound()) + if (!OnDeleteUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); } return false; } - OnDeletePkBool.Broadcast(Context, Args->B); + OnDeleteUniqueU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeletePkBoolWithArgs(const FReducerEventContext& Context, const FDeletePkBoolArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args) { - if (!OnDeletePkBool.IsBound()) + if (!OnDeleteUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); } return false; } - OnDeletePkBool.Broadcast(Context, Args.B); + OnDeleteUniqueU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) { if (!Conn) { @@ -4885,45 +8081,45 @@ void URemoteReducers::DeletePkConnectionId(const FSpacetimeDBConnectionId& A) return; } - FDeletePkConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkConnectionId(ReducerArgs)); } + FDeleteUniqueUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkConnectionId(const FReducerEventContext& Context, const UDeletePkConnectionIdReducer* Args) +bool URemoteReducers::InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args) { - if (!OnDeletePkConnectionId.IsBound()) + if (!OnDeleteUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); } return false; } - OnDeletePkConnectionId.Broadcast(Context, Args->A); + OnDeleteUniqueUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeDeletePkConnectionIdWithArgs(const FReducerEventContext& Context, const FDeletePkConnectionIdArgs& Args) +bool URemoteReducers::InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args) { - if (!OnDeletePkConnectionId.IsBound()) + if (!OnDeleteUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); } return false; } - OnDeletePkConnectionId.Broadcast(Context, Args.A); + OnDeleteUniqueUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertCallTimestamp() { if (!Conn) { @@ -4931,45 +8127,45 @@ void URemoteReducers::DeletePkI128(const FSpacetimeDBInt128& N) return; } - FDeletePkI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI128(ReducerArgs)); } + FInsertCallTimestampArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI128(const FReducerEventContext& Context, const UDeletePkI128Reducer* Args) +bool URemoteReducers::InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args) { - if (!OnDeletePkI128.IsBound()) + if (!OnInsertCallTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); } return false; } - OnDeletePkI128.Broadcast(Context, Args->N); + OnInsertCallTimestamp.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI128WithArgs(const FReducerEventContext& Context, const FDeletePkI128Args& Args) +bool URemoteReducers::InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args) { - if (!OnDeletePkI128.IsBound()) + if (!OnInsertCallTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); } return false; } - OnDeletePkI128.Broadcast(Context, Args.N); + OnInsertCallTimestamp.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI16(const int16 N) +void URemoteReducers::InsertCallUuidV4() { if (!Conn) { @@ -4977,45 +8173,45 @@ void URemoteReducers::DeletePkI16(const int16 N) return; } - FDeletePkI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI16(ReducerArgs)); } + FInsertCallUuidV4Args ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_4"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV4(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI16(const FReducerEventContext& Context, const UDeletePkI16Reducer* Args) +bool URemoteReducers::InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args) { - if (!OnDeletePkI16.IsBound()) + if (!OnInsertCallUuidV4.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); } return false; } - OnDeletePkI16.Broadcast(Context, Args->N); + OnInsertCallUuidV4.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI16WithArgs(const FReducerEventContext& Context, const FDeletePkI16Args& Args) +bool URemoteReducers::InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args) { - if (!OnDeletePkI16.IsBound()) + if (!OnInsertCallUuidV4.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); } return false; } - OnDeletePkI16.Broadcast(Context, Args.N); + OnInsertCallUuidV4.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertCallUuidV7() { if (!Conn) { @@ -5023,45 +8219,45 @@ void URemoteReducers::DeletePkI256(const FSpacetimeDBInt256& N) return; } - FDeletePkI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI256(ReducerArgs)); } + FInsertCallUuidV7Args ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_7"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV7(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI256(const FReducerEventContext& Context, const UDeletePkI256Reducer* Args) +bool URemoteReducers::InvokeInsertCallUuidV7(const FReducerEventContext& Context, const UInsertCallUuidV7Reducer* Args) { - if (!OnDeletePkI256.IsBound()) + if (!OnInsertCallUuidV7.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); } return false; } - OnDeletePkI256.Broadcast(Context, Args->N); + OnInsertCallUuidV7.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI256WithArgs(const FReducerEventContext& Context, const FDeletePkI256Args& Args) +bool URemoteReducers::InvokeInsertCallUuidV7WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV7Args& Args) { - if (!OnDeletePkI256.IsBound()) + if (!OnInsertCallUuidV7.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); } return false; } - OnDeletePkI256.Broadcast(Context, Args.N); + OnInsertCallUuidV7.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI32(const int32 N) +void URemoteReducers::InsertCallerOneConnectionId() { if (!Conn) { @@ -5069,45 +8265,45 @@ void URemoteReducers::DeletePkI32(const int32 N) return; } - FDeletePkI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI32(ReducerArgs)); } + FInsertCallerOneConnectionIdArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI32(const FReducerEventContext& Context, const UDeletePkI32Reducer* Args) +bool URemoteReducers::InvokeInsertCallerOneConnectionId(const FReducerEventContext& Context, const UInsertCallerOneConnectionIdReducer* Args) { - if (!OnDeletePkI32.IsBound()) + if (!OnInsertCallerOneConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); } return false; } - OnDeletePkI32.Broadcast(Context, Args->N); + OnInsertCallerOneConnectionId.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI32WithArgs(const FReducerEventContext& Context, const FDeletePkI32Args& Args) +bool URemoteReducers::InvokeInsertCallerOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerOneConnectionIdArgs& Args) { - if (!OnDeletePkI32.IsBound()) + if (!OnInsertCallerOneConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); } return false; } - OnDeletePkI32.Broadcast(Context, Args.N); + OnInsertCallerOneConnectionId.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI64(const int64 N) +void URemoteReducers::InsertCallerOneIdentity() { if (!Conn) { @@ -5115,45 +8311,45 @@ void URemoteReducers::DeletePkI64(const int64 N) return; } - FDeletePkI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI64(ReducerArgs)); } + FInsertCallerOneIdentityArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI64(const FReducerEventContext& Context, const UDeletePkI64Reducer* Args) +bool URemoteReducers::InvokeInsertCallerOneIdentity(const FReducerEventContext& Context, const UInsertCallerOneIdentityReducer* Args) { - if (!OnDeletePkI64.IsBound()) + if (!OnInsertCallerOneIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); } return false; } - OnDeletePkI64.Broadcast(Context, Args->N); + OnInsertCallerOneIdentity.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkI64WithArgs(const FReducerEventContext& Context, const FDeletePkI64Args& Args) +bool URemoteReducers::InvokeInsertCallerOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerOneIdentityArgs& Args) { - if (!OnDeletePkI64.IsBound()) + if (!OnInsertCallerOneIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); } return false; } - OnDeletePkI64.Broadcast(Context, Args.N); + OnInsertCallerOneIdentity.Broadcast(Context); return true; } -void URemoteReducers::DeletePkI8(const int8 N) +void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) { if (!Conn) { @@ -5161,45 +8357,45 @@ void URemoteReducers::DeletePkI8(const int8 N) return; } - FDeletePkI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkI8(ReducerArgs)); } + FInsertCallerPkConnectionIdArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkI8(const FReducerEventContext& Context, const UDeletePkI8Reducer* Args) +bool URemoteReducers::InvokeInsertCallerPkConnectionId(const FReducerEventContext& Context, const UInsertCallerPkConnectionIdReducer* Args) { - if (!OnDeletePkI8.IsBound()) + if (!OnInsertCallerPkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); } return false; } - OnDeletePkI8.Broadcast(Context, Args->N); + OnInsertCallerPkConnectionId.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkI8WithArgs(const FReducerEventContext& Context, const FDeletePkI8Args& Args) +bool URemoteReducers::InvokeInsertCallerPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerPkConnectionIdArgs& Args) { - if (!OnDeletePkI8.IsBound()) + if (!OnInsertCallerPkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); } return false; } - OnDeletePkI8.Broadcast(Context, Args.N); + OnInsertCallerPkConnectionId.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertCallerPkIdentity(const int32 Data) { if (!Conn) { @@ -5207,45 +8403,45 @@ void URemoteReducers::DeletePkIdentity(const FSpacetimeDBIdentity& I) return; } - FDeletePkIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkIdentity(ReducerArgs)); } + FInsertCallerPkIdentityArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkIdentity(const FReducerEventContext& Context, const UDeletePkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertCallerPkIdentity(const FReducerEventContext& Context, const UInsertCallerPkIdentityReducer* Args) { - if (!OnDeletePkIdentity.IsBound()) + if (!OnInsertCallerPkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); } return false; } - OnDeletePkIdentity.Broadcast(Context, Args->I); + OnInsertCallerPkIdentity.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkIdentityWithArgs(const FReducerEventContext& Context, const FDeletePkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertCallerPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerPkIdentityArgs& Args) { - if (!OnDeletePkIdentity.IsBound()) + if (!OnInsertCallerPkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); } return false; } - OnDeletePkIdentity.Broadcast(Context, Args.I); + OnInsertCallerPkIdentity.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkString(const FString& S) +void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) { if (!Conn) { @@ -5253,45 +8449,45 @@ void URemoteReducers::DeletePkString(const FString& S) return; } - FDeletePkStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkString(ReducerArgs)); } + FInsertCallerUniqueConnectionIdArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkString(const FReducerEventContext& Context, const UDeletePkStringReducer* Args) +bool URemoteReducers::InvokeInsertCallerUniqueConnectionId(const FReducerEventContext& Context, const UInsertCallerUniqueConnectionIdReducer* Args) { - if (!OnDeletePkString.IsBound()) + if (!OnInsertCallerUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); } return false; } - OnDeletePkString.Broadcast(Context, Args->S); + OnInsertCallerUniqueConnectionId.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkStringWithArgs(const FReducerEventContext& Context, const FDeletePkStringArgs& Args) +bool URemoteReducers::InvokeInsertCallerUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueConnectionIdArgs& Args) { - if (!OnDeletePkString.IsBound()) + if (!OnInsertCallerUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); } return false; } - OnDeletePkString.Broadcast(Context, Args.S); + OnInsertCallerUniqueConnectionId.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) { if (!Conn) { @@ -5299,45 +8495,45 @@ void URemoteReducers::DeletePkU128(const FSpacetimeDBUInt128& N) return; } - FDeletePkU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU128(ReducerArgs)); } + FInsertCallerUniqueIdentityArgs ReducerArgs(Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU128(const FReducerEventContext& Context, const UDeletePkU128Reducer* Args) +bool URemoteReducers::InvokeInsertCallerUniqueIdentity(const FReducerEventContext& Context, const UInsertCallerUniqueIdentityReducer* Args) { - if (!OnDeletePkU128.IsBound()) + if (!OnInsertCallerUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); } return false; } - OnDeletePkU128.Broadcast(Context, Args->N); + OnInsertCallerUniqueIdentity.Broadcast(Context, Args->Data); return true; } -bool URemoteReducers::InvokeDeletePkU128WithArgs(const FReducerEventContext& Context, const FDeletePkU128Args& Args) +bool URemoteReducers::InvokeInsertCallerUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueIdentityArgs& Args) { - if (!OnDeletePkU128.IsBound()) + if (!OnInsertCallerUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); } return false; } - OnDeletePkU128.Broadcast(Context, Args.N); + OnInsertCallerUniqueIdentity.Broadcast(Context, Args.Data); return true; } -void URemoteReducers::DeletePkU16(const uint16 N) +void URemoteReducers::InsertCallerVecConnectionId() { if (!Conn) { @@ -5345,45 +8541,45 @@ void URemoteReducers::DeletePkU16(const uint16 N) return; } - FDeletePkU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU16(ReducerArgs)); } + FInsertCallerVecConnectionIdArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU16(const FReducerEventContext& Context, const UDeletePkU16Reducer* Args) +bool URemoteReducers::InvokeInsertCallerVecConnectionId(const FReducerEventContext& Context, const UInsertCallerVecConnectionIdReducer* Args) { - if (!OnDeletePkU16.IsBound()) + if (!OnInsertCallerVecConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); } return false; } - OnDeletePkU16.Broadcast(Context, Args->N); + OnInsertCallerVecConnectionId.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkU16WithArgs(const FReducerEventContext& Context, const FDeletePkU16Args& Args) +bool URemoteReducers::InvokeInsertCallerVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerVecConnectionIdArgs& Args) { - if (!OnDeletePkU16.IsBound()) + if (!OnInsertCallerVecConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); } return false; } - OnDeletePkU16.Broadcast(Context, Args.N); + OnInsertCallerVecConnectionId.Broadcast(Context); return true; } -void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertCallerVecIdentity() { if (!Conn) { @@ -5391,45 +8587,45 @@ void URemoteReducers::DeletePkU256(const FSpacetimeDBUInt256& N) return; } - FDeletePkU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU256(ReducerArgs)); } + FInsertCallerVecIdentityArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU256(const FReducerEventContext& Context, const UDeletePkU256Reducer* Args) +bool URemoteReducers::InvokeInsertCallerVecIdentity(const FReducerEventContext& Context, const UInsertCallerVecIdentityReducer* Args) { - if (!OnDeletePkU256.IsBound()) + if (!OnInsertCallerVecIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); } return false; } - OnDeletePkU256.Broadcast(Context, Args->N); + OnInsertCallerVecIdentity.Broadcast(Context); return true; } -bool URemoteReducers::InvokeDeletePkU256WithArgs(const FReducerEventContext& Context, const FDeletePkU256Args& Args) +bool URemoteReducers::InvokeInsertCallerVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerVecIdentityArgs& Args) { - if (!OnDeletePkU256.IsBound()) + if (!OnInsertCallerVecIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); } return false; } - OnDeletePkU256.Broadcast(Context, Args.N); + OnInsertCallerVecIdentity.Broadcast(Context); return true; } -void URemoteReducers::DeletePkU32(const uint32 N) +void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) { if (!Conn) { @@ -5437,45 +8633,45 @@ void URemoteReducers::DeletePkU32(const uint32 N) return; } - FDeletePkU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32(ReducerArgs)); } + FInsertIntoBtreeU32Args ReducerArgs(Rows); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoBtreeU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32(const FReducerEventContext& Context, const UDeletePkU32Reducer* Args) +bool URemoteReducers::InvokeInsertIntoBtreeU32(const FReducerEventContext& Context, const UInsertIntoBtreeU32Reducer* Args) { - if (!OnDeletePkU32.IsBound()) + if (!OnInsertIntoBtreeU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); } return false; } - OnDeletePkU32.Broadcast(Context, Args->N); + OnInsertIntoBtreeU32.Broadcast(Context, Args->Rows); return true; } -bool URemoteReducers::InvokeDeletePkU32WithArgs(const FReducerEventContext& Context, const FDeletePkU32Args& Args) +bool URemoteReducers::InvokeInsertIntoBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoBtreeU32Args& Args) { - if (!OnDeletePkU32.IsBound()) + if (!OnInsertIntoBtreeU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); } return false; } - OnDeletePkU32.Broadcast(Context, Args.N); + OnInsertIntoBtreeU32.Broadcast(Context, Args.Rows); return true; } -void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) { if (!Conn) { @@ -5483,45 +8679,45 @@ void URemoteReducers::DeletePkU32InsertPkU32Two(const uint32 N, const int32 Data return; } - FDeletePkU32InsertPkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_insert_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32InsertPkU32Two(ReducerArgs)); } + FInsertIntoIndexedSimpleEnumArgs ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_indexed_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoIndexedSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32InsertPkU32Two(const FReducerEventContext& Context, const UDeletePkU32InsertPkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnum(const FReducerEventContext& Context, const UInsertIntoIndexedSimpleEnumReducer* Args) { - if (!OnDeletePkU32InsertPkU32Two.IsBound()) + if (!OnInsertIntoIndexedSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); } return false; } - OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeletePkU32InsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32InsertPkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertIntoIndexedSimpleEnumArgs& Args) { - if (!OnDeletePkU32InsertPkU32Two.IsBound()) + if (!OnInsertIntoIndexedSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); } return false; } - OnDeletePkU32InsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeletePkU32Two(const uint32 N) +void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, const TArray& BtU32) { if (!Conn) { @@ -5529,45 +8725,45 @@ void URemoteReducers::DeletePkU32Two(const uint32 N) return; } - FDeletePkU32TwoArgs ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU32Two(ReducerArgs)); } + FInsertIntoPkBtreeU32Args ReducerArgs(PkU32, BtU32); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_pk_btree_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoPkBtreeU32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU32Two(const FReducerEventContext& Context, const UDeletePkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertIntoPkBtreeU32(const FReducerEventContext& Context, const UInsertIntoPkBtreeU32Reducer* Args) { - if (!OnDeletePkU32Two.IsBound()) + if (!OnInsertIntoPkBtreeU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); } return false; } - OnDeletePkU32Two.Broadcast(Context, Args->N); + OnInsertIntoPkBtreeU32.Broadcast(Context, Args->PkU32, Args->BtU32); return true; } -bool URemoteReducers::InvokeDeletePkU32TwoWithArgs(const FReducerEventContext& Context, const FDeletePkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertIntoPkBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoPkBtreeU32Args& Args) { - if (!OnDeletePkU32Two.IsBound()) + if (!OnInsertIntoPkBtreeU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); } return false; } - OnDeletePkU32Two.Broadcast(Context, Args.N); + OnInsertIntoPkBtreeU32.Broadcast(Context, Args.PkU32, Args.BtU32); return true; } -void URemoteReducers::DeletePkU64(const uint64 N) +void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) { if (!Conn) { @@ -5575,45 +8771,68 @@ void URemoteReducers::DeletePkU64(const uint64 N) return; } - FDeletePkU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU64(ReducerArgs)); } + FInsertLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_large_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertLargeTable(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU64(const FReducerEventContext& Context, const UDeletePkU64Reducer* Args) +bool URemoteReducers::InvokeInsertLargeTable(const FReducerEventContext& Context, const UInsertLargeTableReducer* Args) { - if (!OnDeletePkU64.IsBound()) + if (!OnInsertLargeTable.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); } return false; } - OnDeletePkU64.Broadcast(Context, Args->N); + FInsertLargeTableArgs ArgsStruct; + ArgsStruct.A = Args->A; + ArgsStruct.B = Args->B; + ArgsStruct.C = Args->C; + ArgsStruct.D = Args->D; + ArgsStruct.E = Args->E; + ArgsStruct.F = Args->F; + ArgsStruct.G = Args->G; + ArgsStruct.H = Args->H; + ArgsStruct.I = Args->I; + ArgsStruct.J = Args->J; + ArgsStruct.K = Args->K; + ArgsStruct.L = Args->L; + ArgsStruct.M = Args->M; + ArgsStruct.N = Args->N; + ArgsStruct.O = Args->O; + ArgsStruct.P = Args->P; + ArgsStruct.Q = Args->Q; + ArgsStruct.R = Args->R; + ArgsStruct.S = Args->S; + ArgsStruct.T = Args->T; + ArgsStruct.U = Args->U; + ArgsStruct.V = Args->V; + OnInsertLargeTable.Broadcast(Context, ArgsStruct); return true; } -bool URemoteReducers::InvokeDeletePkU64WithArgs(const FReducerEventContext& Context, const FDeletePkU64Args& Args) +bool URemoteReducers::InvokeInsertLargeTableWithArgs(const FReducerEventContext& Context, const FInsertLargeTableArgs& Args) { - if (!OnDeletePkU64.IsBound()) + if (!OnInsertLargeTable.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); } return false; } - OnDeletePkU64.Broadcast(Context, Args.N); + OnInsertLargeTable.Broadcast(Context, Args); return true; } -void URemoteReducers::DeletePkU8(const uint8 N) +void URemoteReducers::InsertOneBool(const bool B) { if (!Conn) { @@ -5621,45 +8840,45 @@ void URemoteReducers::DeletePkU8(const uint8 N) return; } - FDeletePkU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkU8(ReducerArgs)); } + FInsertOneBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneBool(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkU8(const FReducerEventContext& Context, const UDeletePkU8Reducer* Args) +bool URemoteReducers::InvokeInsertOneBool(const FReducerEventContext& Context, const UInsertOneBoolReducer* Args) { - if (!OnDeletePkU8.IsBound()) + if (!OnInsertOneBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); } return false; } - OnDeletePkU8.Broadcast(Context, Args->N); + OnInsertOneBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeDeletePkU8WithArgs(const FReducerEventContext& Context, const FDeletePkU8Args& Args) +bool URemoteReducers::InvokeInsertOneBoolWithArgs(const FReducerEventContext& Context, const FInsertOneBoolArgs& Args) { - if (!OnDeletePkU8.IsBound()) + if (!OnInsertOneBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); } return false; } - OnDeletePkU8.Broadcast(Context, Args.N); + OnInsertOneBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) { if (!Conn) { @@ -5667,45 +8886,45 @@ void URemoteReducers::DeletePkUuid(const FSpacetimeDBUuid& U) return; } - FDeletePkUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeletePkUuid(ReducerArgs)); } + FInsertOneByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeletePkUuid(const FReducerEventContext& Context, const UDeletePkUuidReducer* Args) +bool URemoteReducers::InvokeInsertOneByteStruct(const FReducerEventContext& Context, const UInsertOneByteStructReducer* Args) { - if (!OnDeletePkUuid.IsBound()) + if (!OnInsertOneByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); } return false; } - OnDeletePkUuid.Broadcast(Context, Args->U); + OnInsertOneByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeletePkUuidWithArgs(const FReducerEventContext& Context, const FDeletePkUuidArgs& Args) +bool URemoteReducers::InvokeInsertOneByteStructWithArgs(const FReducerEventContext& Context, const FInsertOneByteStructArgs& Args) { - if (!OnDeletePkUuid.IsBound()) + if (!OnInsertOneByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeletePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); } return false; } - OnDeletePkUuid.Broadcast(Context, Args.U); + OnInsertOneByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueBool(const bool B) +void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) { if (!Conn) { @@ -5713,45 +8932,45 @@ void URemoteReducers::DeleteUniqueBool(const bool B) return; } - FDeleteUniqueBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueBool(ReducerArgs)); } + FInsertOneConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueBool(const FReducerEventContext& Context, const UDeleteUniqueBoolReducer* Args) +bool URemoteReducers::InvokeInsertOneConnectionId(const FReducerEventContext& Context, const UInsertOneConnectionIdReducer* Args) { - if (!OnDeleteUniqueBool.IsBound()) + if (!OnInsertOneConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); } return false; } - OnDeleteUniqueBool.Broadcast(Context, Args->B); + OnInsertOneConnectionId.Broadcast(Context, Args->A); return true; } -bool URemoteReducers::InvokeDeleteUniqueBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueBoolArgs& Args) +bool URemoteReducers::InvokeInsertOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertOneConnectionIdArgs& Args) { - if (!OnDeleteUniqueBool.IsBound()) + if (!OnInsertOneConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); } return false; } - OnDeleteUniqueBool.Broadcast(Context, Args.B); + OnInsertOneConnectionId.Broadcast(Context, Args.A); return true; } -void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) { if (!Conn) { @@ -5759,45 +8978,45 @@ void URemoteReducers::DeleteUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FDeleteUniqueConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueConnectionId(ReducerArgs)); } + FInsertOneEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueConnectionId(const FReducerEventContext& Context, const UDeleteUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneEnumWithPayload(const FReducerEventContext& Context, const UInsertOneEnumWithPayloadReducer* Args) { - if (!OnDeleteUniqueConnectionId.IsBound()) + if (!OnInsertOneEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); } return false; } - OnDeleteUniqueConnectionId.Broadcast(Context, Args->A); + OnInsertOneEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertOneEnumWithPayloadArgs& Args) { - if (!OnDeleteUniqueConnectionId.IsBound()) + if (!OnInsertOneEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); } return false; } - OnDeleteUniqueConnectionId.Broadcast(Context, Args.A); + OnInsertOneEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructType& S) { if (!Conn) { @@ -5805,45 +9024,45 @@ void URemoteReducers::DeleteUniqueI128(const FSpacetimeDBInt128& N) return; } - FDeleteUniqueI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI128(ReducerArgs)); } + FInsertOneEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI128(const FReducerEventContext& Context, const UDeleteUniqueI128Reducer* Args) +bool URemoteReducers::InvokeInsertOneEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOneEveryPrimitiveStructReducer* Args) { - if (!OnDeleteUniqueI128.IsBound()) + if (!OnInsertOneEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); } return false; } - OnDeleteUniqueI128.Broadcast(Context, Args->N); + OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI128Args& Args) +bool URemoteReducers::InvokeInsertOneEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryPrimitiveStructArgs& Args) { - if (!OnDeleteUniqueI128.IsBound()) + if (!OnInsertOneEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); } return false; } - OnDeleteUniqueI128.Broadcast(Context, Args.N); + OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueI16(const int16 N) +void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) { if (!Conn) { @@ -5851,45 +9070,45 @@ void URemoteReducers::DeleteUniqueI16(const int16 N) return; } - FDeleteUniqueI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI16(ReducerArgs)); } + FInsertOneEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI16(const FReducerEventContext& Context, const UDeleteUniqueI16Reducer* Args) +bool URemoteReducers::InvokeInsertOneEveryVecStruct(const FReducerEventContext& Context, const UInsertOneEveryVecStructReducer* Args) { - if (!OnDeleteUniqueI16.IsBound()) + if (!OnInsertOneEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); } return false; } - OnDeleteUniqueI16.Broadcast(Context, Args->N); + OnInsertOneEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI16Args& Args) +bool URemoteReducers::InvokeInsertOneEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryVecStructArgs& Args) { - if (!OnDeleteUniqueI16.IsBound()) + if (!OnInsertOneEveryVecStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); } return false; } - OnDeleteUniqueI16.Broadcast(Context, Args.N); + OnInsertOneEveryVecStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertOneF32(const float F) { if (!Conn) { @@ -5897,45 +9116,45 @@ void URemoteReducers::DeleteUniqueI256(const FSpacetimeDBInt256& N) return; } - FDeleteUniqueI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI256(ReducerArgs)); } + FInsertOneF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI256(const FReducerEventContext& Context, const UDeleteUniqueI256Reducer* Args) +bool URemoteReducers::InvokeInsertOneF32(const FReducerEventContext& Context, const UInsertOneF32Reducer* Args) { - if (!OnDeleteUniqueI256.IsBound()) + if (!OnInsertOneF32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); } return false; } - OnDeleteUniqueI256.Broadcast(Context, Args->N); + OnInsertOneF32.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeDeleteUniqueI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI256Args& Args) +bool URemoteReducers::InvokeInsertOneF32WithArgs(const FReducerEventContext& Context, const FInsertOneF32Args& Args) { - if (!OnDeleteUniqueI256.IsBound()) + if (!OnInsertOneF32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); } return false; } - OnDeleteUniqueI256.Broadcast(Context, Args.N); + OnInsertOneF32.Broadcast(Context, Args.F); return true; } -void URemoteReducers::DeleteUniqueI32(const int32 N) +void URemoteReducers::InsertOneF64(const double F) { if (!Conn) { @@ -5943,45 +9162,45 @@ void URemoteReducers::DeleteUniqueI32(const int32 N) return; } - FDeleteUniqueI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI32(ReducerArgs)); } + FInsertOneF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI32(const FReducerEventContext& Context, const UDeleteUniqueI32Reducer* Args) +bool URemoteReducers::InvokeInsertOneF64(const FReducerEventContext& Context, const UInsertOneF64Reducer* Args) { - if (!OnDeleteUniqueI32.IsBound()) + if (!OnInsertOneF64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); } return false; } - OnDeleteUniqueI32.Broadcast(Context, Args->N); + OnInsertOneF64.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeDeleteUniqueI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI32Args& Args) +bool URemoteReducers::InvokeInsertOneF64WithArgs(const FReducerEventContext& Context, const FInsertOneF64Args& Args) { - if (!OnDeleteUniqueI32.IsBound()) + if (!OnInsertOneF64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); } return false; } - OnDeleteUniqueI32.Broadcast(Context, Args.N); + OnInsertOneF64.Broadcast(Context, Args.F); return true; } -void URemoteReducers::DeleteUniqueI64(const int64 N) +void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) { if (!Conn) { @@ -5989,45 +9208,45 @@ void URemoteReducers::DeleteUniqueI64(const int64 N) return; } - FDeleteUniqueI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI64(ReducerArgs)); } + FInsertOneI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI64(const FReducerEventContext& Context, const UDeleteUniqueI64Reducer* Args) +bool URemoteReducers::InvokeInsertOneI128(const FReducerEventContext& Context, const UInsertOneI128Reducer* Args) { - if (!OnDeleteUniqueI64.IsBound()) + if (!OnInsertOneI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); } return false; } - OnDeleteUniqueI64.Broadcast(Context, Args->N); + OnInsertOneI128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI64Args& Args) +bool URemoteReducers::InvokeInsertOneI128WithArgs(const FReducerEventContext& Context, const FInsertOneI128Args& Args) { - if (!OnDeleteUniqueI64.IsBound()) + if (!OnInsertOneI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); } return false; } - OnDeleteUniqueI64.Broadcast(Context, Args.N); + OnInsertOneI128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueI8(const int8 N) +void URemoteReducers::InsertOneI16(const int16 N) { if (!Conn) { @@ -6035,45 +9254,45 @@ void URemoteReducers::DeleteUniqueI8(const int8 N) return; } - FDeleteUniqueI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueI8(ReducerArgs)); } + FInsertOneI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI16(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueI8(const FReducerEventContext& Context, const UDeleteUniqueI8Reducer* Args) +bool URemoteReducers::InvokeInsertOneI16(const FReducerEventContext& Context, const UInsertOneI16Reducer* Args) { - if (!OnDeleteUniqueI8.IsBound()) + if (!OnInsertOneI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); } return false; } - OnDeleteUniqueI8.Broadcast(Context, Args->N); + OnInsertOneI16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueI8Args& Args) +bool URemoteReducers::InvokeInsertOneI16WithArgs(const FReducerEventContext& Context, const FInsertOneI16Args& Args) { - if (!OnDeleteUniqueI8.IsBound()) + if (!OnInsertOneI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); } return false; } - OnDeleteUniqueI8.Broadcast(Context, Args.N); + OnInsertOneI16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) { if (!Conn) { @@ -6081,45 +9300,45 @@ void URemoteReducers::DeleteUniqueIdentity(const FSpacetimeDBIdentity& I) return; } - FDeleteUniqueIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueIdentity(ReducerArgs)); } + FInsertOneI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI256(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueIdentity(const FReducerEventContext& Context, const UDeleteUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneI256(const FReducerEventContext& Context, const UInsertOneI256Reducer* Args) { - if (!OnDeleteUniqueIdentity.IsBound()) + if (!OnInsertOneI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); } return false; } - OnDeleteUniqueIdentity.Broadcast(Context, Args->I); + OnInsertOneI256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneI256WithArgs(const FReducerEventContext& Context, const FInsertOneI256Args& Args) { - if (!OnDeleteUniqueIdentity.IsBound()) + if (!OnInsertOneI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); } return false; } - OnDeleteUniqueIdentity.Broadcast(Context, Args.I); + OnInsertOneI256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueString(const FString& S) +void URemoteReducers::InsertOneI32(const int32 N) { if (!Conn) { @@ -6127,45 +9346,45 @@ void URemoteReducers::DeleteUniqueString(const FString& S) return; } - FDeleteUniqueStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueString(ReducerArgs)); } + FInsertOneI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI32(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args) +bool URemoteReducers::InvokeInsertOneI32(const FReducerEventContext& Context, const UInsertOneI32Reducer* Args) { - if (!OnDeleteUniqueString.IsBound()) + if (!OnInsertOneI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); } return false; } - OnDeleteUniqueString.Broadcast(Context, Args->S); + OnInsertOneI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args) +bool URemoteReducers::InvokeInsertOneI32WithArgs(const FReducerEventContext& Context, const FInsertOneI32Args& Args) { - if (!OnDeleteUniqueString.IsBound()) + if (!OnInsertOneI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); } return false; } - OnDeleteUniqueString.Broadcast(Context, Args.S); + OnInsertOneI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertOneI64(const int64 N) { if (!Conn) { @@ -6173,45 +9392,45 @@ void URemoteReducers::DeleteUniqueU128(const FSpacetimeDBUInt128& N) return; } - FDeleteUniqueU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU128(ReducerArgs)); } + FInsertOneI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI64(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args) +bool URemoteReducers::InvokeInsertOneI64(const FReducerEventContext& Context, const UInsertOneI64Reducer* Args) { - if (!OnDeleteUniqueU128.IsBound()) + if (!OnInsertOneI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); } return false; } - OnDeleteUniqueU128.Broadcast(Context, Args->N); + OnInsertOneI64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args) +bool URemoteReducers::InvokeInsertOneI64WithArgs(const FReducerEventContext& Context, const FInsertOneI64Args& Args) { - if (!OnDeleteUniqueU128.IsBound()) + if (!OnInsertOneI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); } return false; } - OnDeleteUniqueU128.Broadcast(Context, Args.N); + OnInsertOneI64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU16(const uint16 N) +void URemoteReducers::InsertOneI8(const int8 N) { if (!Conn) { @@ -6219,45 +9438,45 @@ void URemoteReducers::DeleteUniqueU16(const uint16 N) return; } - FDeleteUniqueU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU16(ReducerArgs)); } + FInsertOneI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI8(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args) +bool URemoteReducers::InvokeInsertOneI8(const FReducerEventContext& Context, const UInsertOneI8Reducer* Args) { - if (!OnDeleteUniqueU16.IsBound()) + if (!OnInsertOneI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); } return false; } - OnDeleteUniqueU16.Broadcast(Context, Args->N); + OnInsertOneI8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args) +bool URemoteReducers::InvokeInsertOneI8WithArgs(const FReducerEventContext& Context, const FInsertOneI8Args& Args) { - if (!OnDeleteUniqueU16.IsBound()) + if (!OnInsertOneI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); } return false; } - OnDeleteUniqueU16.Broadcast(Context, Args.N); + OnInsertOneI8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) { if (!Conn) { @@ -6265,45 +9484,45 @@ void URemoteReducers::DeleteUniqueU256(const FSpacetimeDBUInt256& N) return; } - FDeleteUniqueU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU256(ReducerArgs)); } + FInsertOneIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args) +bool URemoteReducers::InvokeInsertOneIdentity(const FReducerEventContext& Context, const UInsertOneIdentityReducer* Args) { - if (!OnDeleteUniqueU256.IsBound()) + if (!OnInsertOneIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); } return false; } - OnDeleteUniqueU256.Broadcast(Context, Args->N); + OnInsertOneIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args) +bool URemoteReducers::InvokeInsertOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertOneIdentityArgs& Args) { - if (!OnDeleteUniqueU256.IsBound()) + if (!OnInsertOneIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); } return false; } - OnDeleteUniqueU256.Broadcast(Context, Args.N); + OnInsertOneIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::DeleteUniqueU32(const uint32 N) +void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) { if (!Conn) { @@ -6311,45 +9530,45 @@ void URemoteReducers::DeleteUniqueU32(const uint32 N) return; } - FDeleteUniqueU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU32(ReducerArgs)); } + FInsertOneSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args) +bool URemoteReducers::InvokeInsertOneSimpleEnum(const FReducerEventContext& Context, const UInsertOneSimpleEnumReducer* Args) { - if (!OnDeleteUniqueU32.IsBound()) + if (!OnInsertOneSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); } return false; } - OnDeleteUniqueU32.Broadcast(Context, Args->N); + OnInsertOneSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args) +bool URemoteReducers::InvokeInsertOneSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOneSimpleEnumArgs& Args) { - if (!OnDeleteUniqueU32.IsBound()) + if (!OnInsertOneSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); } return false; } - OnDeleteUniqueU32.Broadcast(Context, Args.N); + OnInsertOneSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::DeleteUniqueU64(const uint64 N) +void URemoteReducers::InsertOneString(const FString& S) { if (!Conn) { @@ -6357,45 +9576,45 @@ void URemoteReducers::DeleteUniqueU64(const uint64 N) return; } - FDeleteUniqueU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU64(ReducerArgs)); } + FInsertOneStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneString(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args) +bool URemoteReducers::InvokeInsertOneString(const FReducerEventContext& Context, const UInsertOneStringReducer* Args) { - if (!OnDeleteUniqueU64.IsBound()) + if (!OnInsertOneString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); } return false; } - OnDeleteUniqueU64.Broadcast(Context, Args->N); + OnInsertOneString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args) +bool URemoteReducers::InvokeInsertOneStringWithArgs(const FReducerEventContext& Context, const FInsertOneStringArgs& Args) { - if (!OnDeleteUniqueU64.IsBound()) + if (!OnInsertOneString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); } return false; } - OnDeleteUniqueU64.Broadcast(Context, Args.N); + OnInsertOneString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::DeleteUniqueU8(const uint8 N) +void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) { if (!Conn) { @@ -6403,45 +9622,45 @@ void URemoteReducers::DeleteUniqueU8(const uint8 N) return; } - FDeleteUniqueU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueU8(ReducerArgs)); } + FInsertOneTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args) +bool URemoteReducers::InvokeInsertOneTimestamp(const FReducerEventContext& Context, const UInsertOneTimestampReducer* Args) { - if (!OnDeleteUniqueU8.IsBound()) + if (!OnInsertOneTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); } return false; } - OnDeleteUniqueU8.Broadcast(Context, Args->N); + OnInsertOneTimestamp.Broadcast(Context, Args->T); return true; } -bool URemoteReducers::InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args) +bool URemoteReducers::InvokeInsertOneTimestampWithArgs(const FReducerEventContext& Context, const FInsertOneTimestampArgs& Args) { - if (!OnDeleteUniqueU8.IsBound()) + if (!OnInsertOneTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); } return false; } - OnDeleteUniqueU8.Broadcast(Context, Args.N); + OnInsertOneTimestamp.Broadcast(Context, Args.T); return true; } -void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) { if (!Conn) { @@ -6449,45 +9668,45 @@ void URemoteReducers::DeleteUniqueUuid(const FSpacetimeDBUuid& U) return; } - FDeleteUniqueUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("delete_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::DeleteUniqueUuid(ReducerArgs)); } + FInsertOneU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU128(ReducerArgs)); } } -bool URemoteReducers::InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args) +bool URemoteReducers::InvokeInsertOneU128(const FReducerEventContext& Context, const UInsertOneU128Reducer* Args) { - if (!OnDeleteUniqueUuid.IsBound()) + if (!OnInsertOneU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); } return false; } - OnDeleteUniqueUuid.Broadcast(Context, Args->U); + OnInsertOneU128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args) +bool URemoteReducers::InvokeInsertOneU128WithArgs(const FReducerEventContext& Context, const FInsertOneU128Args& Args) { - if (!OnDeleteUniqueUuid.IsBound()) + if (!OnInsertOneU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for DeleteUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); } return false; } - OnDeleteUniqueUuid.Broadcast(Context, Args.U); + OnInsertOneU128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallTimestamp() +void URemoteReducers::InsertOneU16(const uint16 N) { if (!Conn) { @@ -6495,45 +9714,45 @@ void URemoteReducers::InsertCallTimestamp() return; } - FInsertCallTimestampArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallTimestamp(ReducerArgs)); } + FInsertOneU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args) +bool URemoteReducers::InvokeInsertOneU16(const FReducerEventContext& Context, const UInsertOneU16Reducer* Args) { - if (!OnInsertCallTimestamp.IsBound()) + if (!OnInsertOneU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); } return false; } - OnInsertCallTimestamp.Broadcast(Context); + OnInsertOneU16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args) +bool URemoteReducers::InvokeInsertOneU16WithArgs(const FReducerEventContext& Context, const FInsertOneU16Args& Args) { - if (!OnInsertCallTimestamp.IsBound()) + if (!OnInsertOneU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); } return false; } - OnInsertCallTimestamp.Broadcast(Context); + OnInsertOneU16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallUuidV4() +void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) { if (!Conn) { @@ -6541,45 +9760,45 @@ void URemoteReducers::InsertCallUuidV4() return; } - FInsertCallUuidV4Args ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_4"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV4(ReducerArgs)); } + FInsertOneU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args) +bool URemoteReducers::InvokeInsertOneU256(const FReducerEventContext& Context, const UInsertOneU256Reducer* Args) { - if (!OnInsertCallUuidV4.IsBound()) + if (!OnInsertOneU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); } return false; } - OnInsertCallUuidV4.Broadcast(Context); + OnInsertOneU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args) +bool URemoteReducers::InvokeInsertOneU256WithArgs(const FReducerEventContext& Context, const FInsertOneU256Args& Args) { - if (!OnInsertCallUuidV4.IsBound()) + if (!OnInsertOneU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV4")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); } return false; } - OnInsertCallUuidV4.Broadcast(Context); + OnInsertOneU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallUuidV7() +void URemoteReducers::InsertOneU32(const uint32 N) { if (!Conn) { @@ -6587,45 +9806,45 @@ void URemoteReducers::InsertCallUuidV7() return; } - FInsertCallUuidV7Args ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_call_uuid_v_7"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallUuidV7(ReducerArgs)); } + FInsertOneU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallUuidV7(const FReducerEventContext& Context, const UInsertCallUuidV7Reducer* Args) +bool URemoteReducers::InvokeInsertOneU32(const FReducerEventContext& Context, const UInsertOneU32Reducer* Args) { - if (!OnInsertCallUuidV7.IsBound()) + if (!OnInsertOneU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); } return false; } - OnInsertCallUuidV7.Broadcast(Context); + OnInsertOneU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallUuidV7WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV7Args& Args) +bool URemoteReducers::InvokeInsertOneU32WithArgs(const FReducerEventContext& Context, const FInsertOneU32Args& Args) { - if (!OnInsertCallUuidV7.IsBound()) + if (!OnInsertOneU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallUuidV7")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); } return false; } - OnInsertCallUuidV7.Broadcast(Context); + OnInsertOneU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerOneConnectionId() +void URemoteReducers::InsertOneU64(const uint64 N) { if (!Conn) { @@ -6633,45 +9852,45 @@ void URemoteReducers::InsertCallerOneConnectionId() return; } - FInsertCallerOneConnectionIdArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneConnectionId(ReducerArgs)); } + FInsertOneU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerOneConnectionId(const FReducerEventContext& Context, const UInsertCallerOneConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneU64(const FReducerEventContext& Context, const UInsertOneU64Reducer* Args) { - if (!OnInsertCallerOneConnectionId.IsBound()) + if (!OnInsertOneU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); } return false; } - OnInsertCallerOneConnectionId.Broadcast(Context); + OnInsertOneU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerOneConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneU64WithArgs(const FReducerEventContext& Context, const FInsertOneU64Args& Args) { - if (!OnInsertCallerOneConnectionId.IsBound()) + if (!OnInsertOneU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); } return false; } - OnInsertCallerOneConnectionId.Broadcast(Context); + OnInsertOneU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerOneIdentity() +void URemoteReducers::InsertOneU8(const uint8 N) { if (!Conn) { @@ -6679,45 +9898,45 @@ void URemoteReducers::InsertCallerOneIdentity() return; } - FInsertCallerOneIdentityArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_one_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerOneIdentity(ReducerArgs)); } + FInsertOneU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerOneIdentity(const FReducerEventContext& Context, const UInsertCallerOneIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneU8(const FReducerEventContext& Context, const UInsertOneU8Reducer* Args) { - if (!OnInsertCallerOneIdentity.IsBound()) + if (!OnInsertOneU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); } return false; } - OnInsertCallerOneIdentity.Broadcast(Context); + OnInsertOneU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerOneIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneU8WithArgs(const FReducerEventContext& Context, const FInsertOneU8Args& Args) { - if (!OnInsertCallerOneIdentity.IsBound()) + if (!OnInsertOneU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); } return false; } - OnInsertCallerOneIdentity.Broadcast(Context); + OnInsertOneU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) +void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) { if (!Conn) { @@ -6725,45 +9944,45 @@ void URemoteReducers::InsertCallerPkConnectionId(const int32 Data) return; } - FInsertCallerPkConnectionIdArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkConnectionId(ReducerArgs)); } + FInsertOneUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUnitStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerPkConnectionId(const FReducerEventContext& Context, const UInsertCallerPkConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOneUnitStruct(const FReducerEventContext& Context, const UInsertOneUnitStructReducer* Args) { - if (!OnInsertCallerPkConnectionId.IsBound()) + if (!OnInsertOneUnitStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); } return false; } - OnInsertCallerPkConnectionId.Broadcast(Context, Args->Data); + OnInsertOneUnitStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertCallerPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerPkConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOneUnitStructWithArgs(const FReducerEventContext& Context, const FInsertOneUnitStructArgs& Args) { - if (!OnInsertCallerPkConnectionId.IsBound()) + if (!OnInsertOneUnitStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); } return false; } - OnInsertCallerPkConnectionId.Broadcast(Context, Args.Data); + OnInsertOneUnitStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertCallerPkIdentity(const int32 Data) +void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) { if (!Conn) { @@ -6771,45 +9990,45 @@ void URemoteReducers::InsertCallerPkIdentity(const int32 Data) return; } - FInsertCallerPkIdentityArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerPkIdentity(ReducerArgs)); } + FInsertOneUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerPkIdentity(const FReducerEventContext& Context, const UInsertCallerPkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOneUuid(const FReducerEventContext& Context, const UInsertOneUuidReducer* Args) { - if (!OnInsertCallerPkIdentity.IsBound()) + if (!OnInsertOneUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); } return false; } - OnInsertCallerPkIdentity.Broadcast(Context, Args->Data); + OnInsertOneUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertCallerPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerPkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOneUuidWithArgs(const FReducerEventContext& Context, const FInsertOneUuidArgs& Args) { - if (!OnInsertCallerPkIdentity.IsBound()) + if (!OnInsertOneUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); } return false; } - OnInsertCallerPkIdentity.Broadcast(Context, Args.Data); + OnInsertOneUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) +void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptionalEveryPrimitiveStruct& S) { if (!Conn) { @@ -6817,45 +10036,45 @@ void URemoteReducers::InsertCallerUniqueConnectionId(const int32 Data) return; } - FInsertCallerUniqueConnectionIdArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueConnectionId(ReducerArgs)); } + FInsertOptionEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerUniqueConnectionId(const FReducerEventContext& Context, const UInsertCallerUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOptionEveryPrimitiveStructReducer* Args) { - if (!OnInsertCallerUniqueConnectionId.IsBound()) + if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); } return false; } - OnInsertCallerUniqueConnectionId.Broadcast(Context, Args->Data); + OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertCallerUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOptionEveryPrimitiveStructArgs& Args) { - if (!OnInsertCallerUniqueConnectionId.IsBound()) + if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); } return false; } - OnInsertCallerUniqueConnectionId.Broadcast(Context, Args.Data); + OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) +void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) { if (!Conn) { @@ -6863,45 +10082,45 @@ void URemoteReducers::InsertCallerUniqueIdentity(const int32 Data) return; } - FInsertCallerUniqueIdentityArgs ReducerArgs(Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerUniqueIdentity(ReducerArgs)); } + FInsertOptionI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerUniqueIdentity(const FReducerEventContext& Context, const UInsertCallerUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOptionI32(const FReducerEventContext& Context, const UInsertOptionI32Reducer* Args) { - if (!OnInsertCallerUniqueIdentity.IsBound()) + if (!OnInsertOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); } return false; } - OnInsertCallerUniqueIdentity.Broadcast(Context, Args->Data); + OnInsertOptionI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertCallerUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionI32Args& Args) { - if (!OnInsertCallerUniqueIdentity.IsBound()) + if (!OnInsertOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); } return false; } - OnInsertCallerUniqueIdentity.Broadcast(Context, Args.Data); + OnInsertOptionI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertCallerVecConnectionId() +void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) { if (!Conn) { @@ -6909,45 +10128,45 @@ void URemoteReducers::InsertCallerVecConnectionId() return; } - FInsertCallerVecConnectionIdArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecConnectionId(ReducerArgs)); } + FInsertOptionIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerVecConnectionId(const FReducerEventContext& Context, const UInsertCallerVecConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertOptionIdentity(const FReducerEventContext& Context, const UInsertOptionIdentityReducer* Args) { - if (!OnInsertCallerVecConnectionId.IsBound()) + if (!OnInsertOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); } return false; } - OnInsertCallerVecConnectionId.Broadcast(Context); + OnInsertOptionIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeInsertCallerVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertCallerVecConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertOptionIdentityArgs& Args) { - if (!OnInsertCallerVecConnectionId.IsBound()) + if (!OnInsertOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); } return false; } - OnInsertCallerVecConnectionId.Broadcast(Context); + OnInsertOptionIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::InsertCallerVecIdentity() +void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum& E) { if (!Conn) { @@ -6955,45 +10174,45 @@ void URemoteReducers::InsertCallerVecIdentity() return; } - FInsertCallerVecIdentityArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_caller_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertCallerVecIdentity(ReducerArgs)); } + FInsertOptionSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertCallerVecIdentity(const FReducerEventContext& Context, const UInsertCallerVecIdentityReducer* Args) +bool URemoteReducers::InvokeInsertOptionSimpleEnum(const FReducerEventContext& Context, const UInsertOptionSimpleEnumReducer* Args) { - if (!OnInsertCallerVecIdentity.IsBound()) + if (!OnInsertOptionSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); } return false; } - OnInsertCallerVecIdentity.Broadcast(Context); + OnInsertOptionSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertCallerVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertCallerVecIdentityArgs& Args) +bool URemoteReducers::InvokeInsertOptionSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOptionSimpleEnumArgs& Args) { - if (!OnInsertCallerVecIdentity.IsBound()) + if (!OnInsertOptionSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertCallerVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); } return false; } - OnInsertCallerVecIdentity.Broadcast(Context); + OnInsertOptionSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) +void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) { if (!Conn) { @@ -7001,45 +10220,45 @@ void URemoteReducers::InsertIntoBtreeU32(const TArray& Rows) return; } - FInsertIntoBtreeU32Args ReducerArgs(Rows); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoBtreeU32(ReducerArgs)); } + FInsertOptionStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoBtreeU32(const FReducerEventContext& Context, const UInsertIntoBtreeU32Reducer* Args) +bool URemoteReducers::InvokeInsertOptionString(const FReducerEventContext& Context, const UInsertOptionStringReducer* Args) { - if (!OnInsertIntoBtreeU32.IsBound()) + if (!OnInsertOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); } return false; } - OnInsertIntoBtreeU32.Broadcast(Context, Args->Rows); + OnInsertOptionString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertIntoBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoBtreeU32Args& Args) +bool URemoteReducers::InvokeInsertOptionStringWithArgs(const FReducerEventContext& Context, const FInsertOptionStringArgs& Args) { - if (!OnInsertIntoBtreeU32.IsBound()) + if (!OnInsertOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); } return false; } - OnInsertIntoBtreeU32.Broadcast(Context, Args.Rows); + OnInsertOptionString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) +void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) { if (!Conn) { @@ -7047,45 +10266,45 @@ void URemoteReducers::InsertIntoIndexedSimpleEnum(const ESimpleEnumType& N) return; } - FInsertIntoIndexedSimpleEnumArgs ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_indexed_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoIndexedSimpleEnum(ReducerArgs)); } + FInsertOptionUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnum(const FReducerEventContext& Context, const UInsertIntoIndexedSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertOptionUuid(const FReducerEventContext& Context, const UInsertOptionUuidReducer* Args) { - if (!OnInsertIntoIndexedSimpleEnum.IsBound()) + if (!OnInsertOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); } return false; } - OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args->N); + OnInsertOptionUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertIntoIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertIntoIndexedSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertOptionUuidArgs& Args) { - if (!OnInsertIntoIndexedSimpleEnum.IsBound()) + if (!OnInsertOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); } return false; } - OnInsertIntoIndexedSimpleEnum.Broadcast(Context, Args.N); + OnInsertOptionUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, const TArray& BtU32) +void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptionalInt32& V) { if (!Conn) { @@ -7093,45 +10312,45 @@ void URemoteReducers::InsertIntoPkBtreeU32(const TArray& PkU32, cons return; } - FInsertIntoPkBtreeU32Args ReducerArgs(PkU32, BtU32); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_into_pk_btree_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertIntoPkBtreeU32(ReducerArgs)); } + FInsertOptionVecOptionI32Args ReducerArgs(V); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_vec_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionVecOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertIntoPkBtreeU32(const FReducerEventContext& Context, const UInsertIntoPkBtreeU32Reducer* Args) +bool URemoteReducers::InvokeInsertOptionVecOptionI32(const FReducerEventContext& Context, const UInsertOptionVecOptionI32Reducer* Args) { - if (!OnInsertIntoPkBtreeU32.IsBound()) + if (!OnInsertOptionVecOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); } return false; } - OnInsertIntoPkBtreeU32.Broadcast(Context, Args->PkU32, Args->BtU32); + OnInsertOptionVecOptionI32.Broadcast(Context, Args->V); return true; } -bool URemoteReducers::InvokeInsertIntoPkBtreeU32WithArgs(const FReducerEventContext& Context, const FInsertIntoPkBtreeU32Args& Args) +bool URemoteReducers::InvokeInsertOptionVecOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionVecOptionI32Args& Args) { - if (!OnInsertIntoPkBtreeU32.IsBound()) + if (!OnInsertOptionVecOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertIntoPkBtreeU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); } return false; } - OnInsertIntoPkBtreeU32.Broadcast(Context, Args.PkU32, Args.BtU32); + OnInsertOptionVecOptionI32.Broadcast(Context, Args.V); return true; } -void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint32 C, const uint64 D, const FSpacetimeDBUInt128& E, const FSpacetimeDBUInt256& F, const int8 G, const int16 H, const int32 I, const int64 J, const FSpacetimeDBInt128& K, const FSpacetimeDBInt256& L, const bool M, const float N, const double O, const FString& P, const ESimpleEnumType& Q, const FEnumWithPayloadType& R, const FUnitStructType& S, const FByteStructType& T, const FEveryPrimitiveStructType& U, const FEveryVecStructType& V) +void URemoteReducers::InsertPkBool(const bool B, const int32 Data) { if (!Conn) { @@ -7139,68 +10358,45 @@ void URemoteReducers::InsertLargeTable(const uint8 A, const uint16 B, const uint return; } - FInsertLargeTableArgs ReducerArgs(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_large_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertLargeTable(ReducerArgs)); } + FInsertPkBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertLargeTable(const FReducerEventContext& Context, const UInsertLargeTableReducer* Args) +bool URemoteReducers::InvokeInsertPkBool(const FReducerEventContext& Context, const UInsertPkBoolReducer* Args) { - if (!OnInsertLargeTable.IsBound()) + if (!OnInsertPkBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); } return false; } - FInsertLargeTableArgs ArgsStruct; - ArgsStruct.A = Args->A; - ArgsStruct.B = Args->B; - ArgsStruct.C = Args->C; - ArgsStruct.D = Args->D; - ArgsStruct.E = Args->E; - ArgsStruct.F = Args->F; - ArgsStruct.G = Args->G; - ArgsStruct.H = Args->H; - ArgsStruct.I = Args->I; - ArgsStruct.J = Args->J; - ArgsStruct.K = Args->K; - ArgsStruct.L = Args->L; - ArgsStruct.M = Args->M; - ArgsStruct.N = Args->N; - ArgsStruct.O = Args->O; - ArgsStruct.P = Args->P; - ArgsStruct.Q = Args->Q; - ArgsStruct.R = Args->R; - ArgsStruct.S = Args->S; - ArgsStruct.T = Args->T; - ArgsStruct.U = Args->U; - ArgsStruct.V = Args->V; - OnInsertLargeTable.Broadcast(Context, ArgsStruct); + OnInsertPkBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertLargeTableWithArgs(const FReducerEventContext& Context, const FInsertLargeTableArgs& Args) +bool URemoteReducers::InvokeInsertPkBoolWithArgs(const FReducerEventContext& Context, const FInsertPkBoolArgs& Args) { - if (!OnInsertLargeTable.IsBound()) + if (!OnInsertPkBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertLargeTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); } return false; } - OnInsertLargeTable.Broadcast(Context, Args); + OnInsertPkBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertOneBool(const bool B) +void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -7208,45 +10404,45 @@ void URemoteReducers::InsertOneBool(const bool B) return; } - FInsertOneBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneBool(ReducerArgs)); } + FInsertPkConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneBool(const FReducerEventContext& Context, const UInsertOneBoolReducer* Args) +bool URemoteReducers::InvokeInsertPkConnectionId(const FReducerEventContext& Context, const UInsertPkConnectionIdReducer* Args) { - if (!OnInsertOneBool.IsBound()) + if (!OnInsertPkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); } return false; } - OnInsertOneBool.Broadcast(Context, Args->B); + OnInsertPkConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneBoolWithArgs(const FReducerEventContext& Context, const FInsertOneBoolArgs& Args) +bool URemoteReducers::InvokeInsertPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertPkConnectionIdArgs& Args) { - if (!OnInsertOneBool.IsBound()) + if (!OnInsertPkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); } return false; } - OnInsertOneBool.Broadcast(Context, Args.B); + OnInsertPkConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) +void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -7254,45 +10450,45 @@ void URemoteReducers::InsertOneByteStruct(const FByteStructType& S) return; } - FInsertOneByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneByteStruct(ReducerArgs)); } + FInsertPkI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneByteStruct(const FReducerEventContext& Context, const UInsertOneByteStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI128(const FReducerEventContext& Context, const UInsertPkI128Reducer* Args) { - if (!OnInsertOneByteStruct.IsBound()) + if (!OnInsertPkI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); } return false; } - OnInsertOneByteStruct.Broadcast(Context, Args->S); + OnInsertPkI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneByteStructWithArgs(const FReducerEventContext& Context, const FInsertOneByteStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI128WithArgs(const FReducerEventContext& Context, const FInsertPkI128Args& Args) { - if (!OnInsertOneByteStruct.IsBound()) + if (!OnInsertPkI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); } return false; } - OnInsertOneByteStruct.Broadcast(Context, Args.S); + OnInsertPkI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) +void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) { if (!Conn) { @@ -7300,45 +10496,45 @@ void URemoteReducers::InsertOneConnectionId(const FSpacetimeDBConnectionId& A) return; } - FInsertOneConnectionIdArgs ReducerArgs(A); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneConnectionId(ReducerArgs)); } + FInsertPkI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneConnectionId(const FReducerEventContext& Context, const UInsertOneConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertPkI16(const FReducerEventContext& Context, const UInsertPkI16Reducer* Args) { - if (!OnInsertOneConnectionId.IsBound()) + if (!OnInsertPkI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); } return false; } - OnInsertOneConnectionId.Broadcast(Context, Args->A); + OnInsertPkI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertOneConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertPkI16WithArgs(const FReducerEventContext& Context, const FInsertPkI16Args& Args) { - if (!OnInsertOneConnectionId.IsBound()) + if (!OnInsertPkI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); } return false; } - OnInsertOneConnectionId.Broadcast(Context, Args.A); + OnInsertPkI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) +void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -7346,45 +10542,45 @@ void URemoteReducers::InsertOneEnumWithPayload(const FEnumWithPayloadType& E) return; } - FInsertOneEnumWithPayloadArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEnumWithPayload(ReducerArgs)); } + FInsertPkI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEnumWithPayload(const FReducerEventContext& Context, const UInsertOneEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeInsertPkI256(const FReducerEventContext& Context, const UInsertPkI256Reducer* Args) { - if (!OnInsertOneEnumWithPayload.IsBound()) + if (!OnInsertPkI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); } return false; } - OnInsertOneEnumWithPayload.Broadcast(Context, Args->E); + OnInsertPkI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertOneEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeInsertPkI256WithArgs(const FReducerEventContext& Context, const FInsertPkI256Args& Args) { - if (!OnInsertOneEnumWithPayload.IsBound()) + if (!OnInsertPkI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); } return false; } - OnInsertOneEnumWithPayload.Broadcast(Context, Args.E); + OnInsertPkI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructType& S) +void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) { if (!Conn) { @@ -7392,45 +10588,45 @@ void URemoteReducers::InsertOneEveryPrimitiveStruct(const FEveryPrimitiveStructT return; } - FInsertOneEveryPrimitiveStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryPrimitiveStruct(ReducerArgs)); } + FInsertPkI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOneEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI32(const FReducerEventContext& Context, const UInsertPkI32Reducer* Args) { - if (!OnInsertOneEveryPrimitiveStruct.IsBound()) + if (!OnInsertPkI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); } return false; } - OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertPkI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI32WithArgs(const FReducerEventContext& Context, const FInsertPkI32Args& Args) { - if (!OnInsertOneEveryPrimitiveStruct.IsBound()) + if (!OnInsertPkI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); } return false; } - OnInsertOneEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertPkI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) +void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) { if (!Conn) { @@ -7438,45 +10634,45 @@ void URemoteReducers::InsertOneEveryVecStruct(const FEveryVecStructType& S) return; } - FInsertOneEveryVecStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneEveryVecStruct(ReducerArgs)); } + FInsertPkI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneEveryVecStruct(const FReducerEventContext& Context, const UInsertOneEveryVecStructReducer* Args) +bool URemoteReducers::InvokeInsertPkI64(const FReducerEventContext& Context, const UInsertPkI64Reducer* Args) { - if (!OnInsertOneEveryVecStruct.IsBound()) + if (!OnInsertPkI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); } return false; } - OnInsertOneEveryVecStruct.Broadcast(Context, Args->S); + OnInsertPkI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertOneEveryVecStructArgs& Args) +bool URemoteReducers::InvokeInsertPkI64WithArgs(const FReducerEventContext& Context, const FInsertPkI64Args& Args) { - if (!OnInsertOneEveryVecStruct.IsBound()) + if (!OnInsertPkI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); } return false; } - OnInsertOneEveryVecStruct.Broadcast(Context, Args.S); + OnInsertPkI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneF32(const float F) +void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) { if (!Conn) { @@ -7484,45 +10680,45 @@ void URemoteReducers::InsertOneF32(const float F) return; } - FInsertOneF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF32(ReducerArgs)); } + FInsertPkI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneF32(const FReducerEventContext& Context, const UInsertOneF32Reducer* Args) +bool URemoteReducers::InvokeInsertPkI8(const FReducerEventContext& Context, const UInsertPkI8Reducer* Args) { - if (!OnInsertOneF32.IsBound()) + if (!OnInsertPkI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); } return false; } - OnInsertOneF32.Broadcast(Context, Args->F); + OnInsertPkI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneF32WithArgs(const FReducerEventContext& Context, const FInsertOneF32Args& Args) +bool URemoteReducers::InvokeInsertPkI8WithArgs(const FReducerEventContext& Context, const FInsertPkI8Args& Args) { - if (!OnInsertOneF32.IsBound()) + if (!OnInsertPkI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); } return false; } - OnInsertOneF32.Broadcast(Context, Args.F); + OnInsertPkI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneF64(const double F) +void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -7530,45 +10726,45 @@ void URemoteReducers::InsertOneF64(const double F) return; } - FInsertOneF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneF64(ReducerArgs)); } + FInsertPkIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneF64(const FReducerEventContext& Context, const UInsertOneF64Reducer* Args) +bool URemoteReducers::InvokeInsertPkIdentity(const FReducerEventContext& Context, const UInsertPkIdentityReducer* Args) { - if (!OnInsertOneF64.IsBound()) + if (!OnInsertPkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); } return false; } - OnInsertOneF64.Broadcast(Context, Args->F); + OnInsertPkIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneF64WithArgs(const FReducerEventContext& Context, const FInsertOneF64Args& Args) +bool URemoteReducers::InvokeInsertPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertPkIdentityArgs& Args) { - if (!OnInsertOneF64.IsBound()) + if (!OnInsertPkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); } return false; } - OnInsertOneF64.Broadcast(Context, Args.F); + OnInsertPkIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) +void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 Data) { if (!Conn) { @@ -7576,45 +10772,45 @@ void URemoteReducers::InsertOneI128(const FSpacetimeDBInt128& N) return; } - FInsertOneI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI128(ReducerArgs)); } + FInsertPkSimpleEnumArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI128(const FReducerEventContext& Context, const UInsertOneI128Reducer* Args) +bool URemoteReducers::InvokeInsertPkSimpleEnum(const FReducerEventContext& Context, const UInsertPkSimpleEnumReducer* Args) { - if (!OnInsertOneI128.IsBound()) + if (!OnInsertPkSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); } return false; } - OnInsertOneI128.Broadcast(Context, Args->N); + OnInsertPkSimpleEnum.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI128WithArgs(const FReducerEventContext& Context, const FInsertOneI128Args& Args) +bool URemoteReducers::InvokeInsertPkSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertPkSimpleEnumArgs& Args) { - if (!OnInsertOneI128.IsBound()) + if (!OnInsertPkSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); } return false; } - OnInsertOneI128.Broadcast(Context, Args.N); + OnInsertPkSimpleEnum.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOneI16(const int16 N) +void URemoteReducers::InsertPkString(const FString& S, const int32 Data) { if (!Conn) { @@ -7622,45 +10818,45 @@ void URemoteReducers::InsertOneI16(const int16 N) return; } - FInsertOneI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI16(ReducerArgs)); } + FInsertPkStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI16(const FReducerEventContext& Context, const UInsertOneI16Reducer* Args) +bool URemoteReducers::InvokeInsertPkString(const FReducerEventContext& Context, const UInsertPkStringReducer* Args) { - if (!OnInsertOneI16.IsBound()) + if (!OnInsertPkString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); } return false; } - OnInsertOneI16.Broadcast(Context, Args->N); + OnInsertPkString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI16WithArgs(const FReducerEventContext& Context, const FInsertOneI16Args& Args) +bool URemoteReducers::InvokeInsertPkStringWithArgs(const FReducerEventContext& Context, const FInsertPkStringArgs& Args) { - if (!OnInsertOneI16.IsBound()) + if (!OnInsertPkString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); } return false; } - OnInsertOneI16.Broadcast(Context, Args.N); + OnInsertPkString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) +void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -7668,45 +10864,45 @@ void URemoteReducers::InsertOneI256(const FSpacetimeDBInt256& N) return; } - FInsertOneI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI256(ReducerArgs)); } + FInsertPkU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI256(const FReducerEventContext& Context, const UInsertOneI256Reducer* Args) +bool URemoteReducers::InvokeInsertPkU128(const FReducerEventContext& Context, const UInsertPkU128Reducer* Args) { - if (!OnInsertOneI256.IsBound()) + if (!OnInsertPkU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); } return false; } - OnInsertOneI256.Broadcast(Context, Args->N); + OnInsertPkU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI256WithArgs(const FReducerEventContext& Context, const FInsertOneI256Args& Args) +bool URemoteReducers::InvokeInsertPkU128WithArgs(const FReducerEventContext& Context, const FInsertPkU128Args& Args) { - if (!OnInsertOneI256.IsBound()) + if (!OnInsertPkU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); } return false; } - OnInsertOneI256.Broadcast(Context, Args.N); + OnInsertPkU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI32(const int32 N) +void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -7714,45 +10910,45 @@ void URemoteReducers::InsertOneI32(const int32 N) return; } - FInsertOneI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI32(ReducerArgs)); } + FInsertPkU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI32(const FReducerEventContext& Context, const UInsertOneI32Reducer* Args) +bool URemoteReducers::InvokeInsertPkU16(const FReducerEventContext& Context, const UInsertPkU16Reducer* Args) { - if (!OnInsertOneI32.IsBound()) + if (!OnInsertPkU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); } return false; } - OnInsertOneI32.Broadcast(Context, Args->N); + OnInsertPkU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI32WithArgs(const FReducerEventContext& Context, const FInsertOneI32Args& Args) +bool URemoteReducers::InvokeInsertPkU16WithArgs(const FReducerEventContext& Context, const FInsertPkU16Args& Args) { - if (!OnInsertOneI32.IsBound()) + if (!OnInsertPkU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); } return false; } - OnInsertOneI32.Broadcast(Context, Args.N); + OnInsertPkU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI64(const int64 N) +void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -7760,45 +10956,45 @@ void URemoteReducers::InsertOneI64(const int64 N) return; } - FInsertOneI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI64(ReducerArgs)); } + FInsertPkU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI64(const FReducerEventContext& Context, const UInsertOneI64Reducer* Args) +bool URemoteReducers::InvokeInsertPkU256(const FReducerEventContext& Context, const UInsertPkU256Reducer* Args) { - if (!OnInsertOneI64.IsBound()) + if (!OnInsertPkU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); } return false; } - OnInsertOneI64.Broadcast(Context, Args->N); + OnInsertPkU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI64WithArgs(const FReducerEventContext& Context, const FInsertOneI64Args& Args) +bool URemoteReducers::InvokeInsertPkU256WithArgs(const FReducerEventContext& Context, const FInsertPkU256Args& Args) { - if (!OnInsertOneI64.IsBound()) + if (!OnInsertPkU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); } return false; } - OnInsertOneI64.Broadcast(Context, Args.N); + OnInsertPkU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneI8(const int8 N) +void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -7806,45 +11002,45 @@ void URemoteReducers::InsertOneI8(const int8 N) return; } - FInsertOneI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneI8(ReducerArgs)); } + FInsertPkU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneI8(const FReducerEventContext& Context, const UInsertOneI8Reducer* Args) +bool URemoteReducers::InvokeInsertPkU32(const FReducerEventContext& Context, const UInsertPkU32Reducer* Args) { - if (!OnInsertOneI8.IsBound()) + if (!OnInsertPkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); } return false; } - OnInsertOneI8.Broadcast(Context, Args->N); + OnInsertPkU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneI8WithArgs(const FReducerEventContext& Context, const FInsertOneI8Args& Args) +bool URemoteReducers::InvokeInsertPkU32WithArgs(const FReducerEventContext& Context, const FInsertPkU32Args& Args) { - if (!OnInsertOneI8.IsBound()) + if (!OnInsertPkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); } return false; } - OnInsertOneI8.Broadcast(Context, Args.N); + OnInsertPkU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) +void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) { if (!Conn) { @@ -7852,45 +11048,45 @@ void URemoteReducers::InsertOneIdentity(const FSpacetimeDBIdentity& I) return; } - FInsertOneIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneIdentity(ReducerArgs)); } + FInsertPkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32Two(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneIdentity(const FReducerEventContext& Context, const UInsertOneIdentityReducer* Args) +bool URemoteReducers::InvokeInsertPkU32Two(const FReducerEventContext& Context, const UInsertPkU32TwoReducer* Args) { - if (!OnInsertOneIdentity.IsBound()) + if (!OnInsertPkU32Two.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); } return false; } - OnInsertOneIdentity.Broadcast(Context, Args->I); + OnInsertPkU32Two.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneIdentityWithArgs(const FReducerEventContext& Context, const FInsertOneIdentityArgs& Args) +bool URemoteReducers::InvokeInsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FInsertPkU32TwoArgs& Args) { - if (!OnInsertOneIdentity.IsBound()) + if (!OnInsertPkU32Two.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); } return false; } - OnInsertOneIdentity.Broadcast(Context, Args.I); + OnInsertPkU32Two.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) +void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -7898,45 +11094,45 @@ void URemoteReducers::InsertOneSimpleEnum(const ESimpleEnumType& E) return; } - FInsertOneSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneSimpleEnum(ReducerArgs)); } + FInsertPkU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneSimpleEnum(const FReducerEventContext& Context, const UInsertOneSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertPkU64(const FReducerEventContext& Context, const UInsertPkU64Reducer* Args) { - if (!OnInsertOneSimpleEnum.IsBound()) + if (!OnInsertPkU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); } return false; } - OnInsertOneSimpleEnum.Broadcast(Context, Args->E); + OnInsertPkU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOneSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertPkU64WithArgs(const FReducerEventContext& Context, const FInsertPkU64Args& Args) { - if (!OnInsertOneSimpleEnum.IsBound()) + if (!OnInsertPkU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); } return false; } - OnInsertOneSimpleEnum.Broadcast(Context, Args.E); + OnInsertPkU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneString(const FString& S) +void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -7944,45 +11140,45 @@ void URemoteReducers::InsertOneString(const FString& S) return; } - FInsertOneStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneString(ReducerArgs)); } + FInsertPkU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneString(const FReducerEventContext& Context, const UInsertOneStringReducer* Args) +bool URemoteReducers::InvokeInsertPkU8(const FReducerEventContext& Context, const UInsertPkU8Reducer* Args) { - if (!OnInsertOneString.IsBound()) + if (!OnInsertPkU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); } return false; } - OnInsertOneString.Broadcast(Context, Args->S); + OnInsertPkU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneStringWithArgs(const FReducerEventContext& Context, const FInsertOneStringArgs& Args) +bool URemoteReducers::InvokeInsertPkU8WithArgs(const FReducerEventContext& Context, const FInsertPkU8Args& Args) { - if (!OnInsertOneString.IsBound()) + if (!OnInsertPkU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); } return false; } - OnInsertOneString.Broadcast(Context, Args.S); + OnInsertPkU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) +void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -7990,45 +11186,45 @@ void URemoteReducers::InsertOneTimestamp(const FSpacetimeDBTimestamp& T) return; } - FInsertOneTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneTimestamp(ReducerArgs)); } + FInsertPkUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneTimestamp(const FReducerEventContext& Context, const UInsertOneTimestampReducer* Args) +bool URemoteReducers::InvokeInsertPkUuid(const FReducerEventContext& Context, const UInsertPkUuidReducer* Args) { - if (!OnInsertOneTimestamp.IsBound()) + if (!OnInsertPkUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); } return false; } - OnInsertOneTimestamp.Broadcast(Context, Args->T); + OnInsertPkUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOneTimestampWithArgs(const FReducerEventContext& Context, const FInsertOneTimestampArgs& Args) +bool URemoteReducers::InvokeInsertPkUuidWithArgs(const FReducerEventContext& Context, const FInsertPkUuidArgs& Args) { - if (!OnInsertOneTimestamp.IsBound()) + if (!OnInsertPkUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); } return false; } - OnInsertOneTimestamp.Broadcast(Context, Args.T); + OnInsertPkUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) +void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& S) { if (!Conn) { @@ -8036,45 +11232,45 @@ void URemoteReducers::InsertOneU128(const FSpacetimeDBUInt128& N) return; } - FInsertOneU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU128(ReducerArgs)); } + FInsertPrimitivesAsStringsArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_primitives_as_strings"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPrimitivesAsStrings(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU128(const FReducerEventContext& Context, const UInsertOneU128Reducer* Args) +bool URemoteReducers::InvokeInsertPrimitivesAsStrings(const FReducerEventContext& Context, const UInsertPrimitivesAsStringsReducer* Args) { - if (!OnInsertOneU128.IsBound()) + if (!OnInsertPrimitivesAsStrings.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); } return false; } - OnInsertOneU128.Broadcast(Context, Args->N); + OnInsertPrimitivesAsStrings.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertOneU128WithArgs(const FReducerEventContext& Context, const FInsertOneU128Args& Args) +bool URemoteReducers::InvokeInsertPrimitivesAsStringsWithArgs(const FReducerEventContext& Context, const FInsertPrimitivesAsStringsArgs& Args) { - if (!OnInsertOneU128.IsBound()) + if (!OnInsertPrimitivesAsStrings.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); } return false; } - OnInsertOneU128.Broadcast(Context, Args.N); + OnInsertPrimitivesAsStrings.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertOneU16(const uint16 N) +void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientResultEveryPrimitiveStructString& R) { if (!Conn) { @@ -8082,45 +11278,45 @@ void URemoteReducers::InsertOneU16(const uint16 N) return; } - FInsertOneU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU16(ReducerArgs)); } + FInsertResultEveryPrimitiveStructStringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_every_primitive_struct_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultEveryPrimitiveStructString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU16(const FReducerEventContext& Context, const UInsertOneU16Reducer* Args) +bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructString(const FReducerEventContext& Context, const UInsertResultEveryPrimitiveStructStringReducer* Args) { - if (!OnInsertOneU16.IsBound()) + if (!OnInsertResultEveryPrimitiveStructString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); } return false; } - OnInsertOneU16.Broadcast(Context, Args->N); + OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU16WithArgs(const FReducerEventContext& Context, const FInsertOneU16Args& Args) +bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructStringWithArgs(const FReducerEventContext& Context, const FInsertResultEveryPrimitiveStructStringArgs& Args) { - if (!OnInsertOneU16.IsBound()) + if (!OnInsertResultEveryPrimitiveStructString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); } return false; } - OnInsertOneU16.Broadcast(Context, Args.N); + OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) +void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& R) { if (!Conn) { @@ -8128,45 +11324,45 @@ void URemoteReducers::InsertOneU256(const FSpacetimeDBUInt256& N) return; } - FInsertOneU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU256(ReducerArgs)); } + FInsertResultI32StringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_i_32_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultI32String(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU256(const FReducerEventContext& Context, const UInsertOneU256Reducer* Args) +bool URemoteReducers::InvokeInsertResultI32String(const FReducerEventContext& Context, const UInsertResultI32StringReducer* Args) { - if (!OnInsertOneU256.IsBound()) + if (!OnInsertResultI32String.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); } return false; } - OnInsertOneU256.Broadcast(Context, Args->N); + OnInsertResultI32String.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU256WithArgs(const FReducerEventContext& Context, const FInsertOneU256Args& Args) +bool URemoteReducers::InvokeInsertResultI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultI32StringArgs& Args) { - if (!OnInsertOneU256.IsBound()) + if (!OnInsertResultI32String.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); } return false; } - OnInsertOneU256.Broadcast(Context, Args.N); + OnInsertResultI32String.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU32(const uint32 N) +void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentityString& R) { if (!Conn) { @@ -8174,45 +11370,45 @@ void URemoteReducers::InsertOneU32(const uint32 N) return; } - FInsertOneU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU32(ReducerArgs)); } + FInsertResultIdentityStringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_identity_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultIdentityString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU32(const FReducerEventContext& Context, const UInsertOneU32Reducer* Args) +bool URemoteReducers::InvokeInsertResultIdentityString(const FReducerEventContext& Context, const UInsertResultIdentityStringReducer* Args) { - if (!OnInsertOneU32.IsBound()) + if (!OnInsertResultIdentityString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); } return false; } - OnInsertOneU32.Broadcast(Context, Args->N); + OnInsertResultIdentityString.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU32WithArgs(const FReducerEventContext& Context, const FInsertOneU32Args& Args) +bool URemoteReducers::InvokeInsertResultIdentityStringWithArgs(const FReducerEventContext& Context, const FInsertResultIdentityStringArgs& Args) { - if (!OnInsertOneU32.IsBound()) + if (!OnInsertResultIdentityString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); } return false; } - OnInsertOneU32.Broadcast(Context, Args.N); + OnInsertResultIdentityString.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU64(const uint64 N) +void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnumInt32& R) { if (!Conn) { @@ -8220,45 +11416,45 @@ void URemoteReducers::InsertOneU64(const uint64 N) return; } - FInsertOneU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU64(ReducerArgs)); } + FInsertResultSimpleEnumI32Args ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_simple_enum_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultSimpleEnumI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU64(const FReducerEventContext& Context, const UInsertOneU64Reducer* Args) +bool URemoteReducers::InvokeInsertResultSimpleEnumI32(const FReducerEventContext& Context, const UInsertResultSimpleEnumI32Reducer* Args) { - if (!OnInsertOneU64.IsBound()) + if (!OnInsertResultSimpleEnumI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); } return false; } - OnInsertOneU64.Broadcast(Context, Args->N); + OnInsertResultSimpleEnumI32.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU64WithArgs(const FReducerEventContext& Context, const FInsertOneU64Args& Args) +bool URemoteReducers::InvokeInsertResultSimpleEnumI32WithArgs(const FReducerEventContext& Context, const FInsertResultSimpleEnumI32Args& Args) { - if (!OnInsertOneU64.IsBound()) + if (!OnInsertResultSimpleEnumI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); } return false; } - OnInsertOneU64.Broadcast(Context, Args.N); + OnInsertResultSimpleEnumI32.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneU8(const uint8 N) +void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& R) { if (!Conn) { @@ -8266,45 +11462,45 @@ void URemoteReducers::InsertOneU8(const uint8 N) return; } - FInsertOneU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneU8(ReducerArgs)); } + FInsertResultStringI32Args ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_string_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultStringI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneU8(const FReducerEventContext& Context, const UInsertOneU8Reducer* Args) +bool URemoteReducers::InvokeInsertResultStringI32(const FReducerEventContext& Context, const UInsertResultStringI32Reducer* Args) { - if (!OnInsertOneU8.IsBound()) + if (!OnInsertResultStringI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); } return false; } - OnInsertOneU8.Broadcast(Context, Args->N); + OnInsertResultStringI32.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneU8WithArgs(const FReducerEventContext& Context, const FInsertOneU8Args& Args) +bool URemoteReducers::InvokeInsertResultStringI32WithArgs(const FReducerEventContext& Context, const FInsertResultStringI32Args& Args) { - if (!OnInsertOneU8.IsBound()) + if (!OnInsertResultStringI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); } return false; } - OnInsertOneU8.Broadcast(Context, Args.N); + OnInsertResultStringI32.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) +void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32String& R) { if (!Conn) { @@ -8312,45 +11508,45 @@ void URemoteReducers::InsertOneUnitStruct(const FUnitStructType& S) return; } - FInsertOneUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUnitStruct(ReducerArgs)); } + FInsertResultVecI32StringArgs ReducerArgs(R); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_vec_i_32_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultVecI32String(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneUnitStruct(const FReducerEventContext& Context, const UInsertOneUnitStructReducer* Args) +bool URemoteReducers::InvokeInsertResultVecI32String(const FReducerEventContext& Context, const UInsertResultVecI32StringReducer* Args) { - if (!OnInsertOneUnitStruct.IsBound()) + if (!OnInsertResultVecI32String.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); } return false; } - OnInsertOneUnitStruct.Broadcast(Context, Args->S); + OnInsertResultVecI32String.Broadcast(Context, Args->R); return true; } -bool URemoteReducers::InvokeInsertOneUnitStructWithArgs(const FReducerEventContext& Context, const FInsertOneUnitStructArgs& Args) +bool URemoteReducers::InvokeInsertResultVecI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultVecI32StringArgs& Args) { - if (!OnInsertOneUnitStruct.IsBound()) + if (!OnInsertResultVecI32String.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); } return false; } - OnInsertOneUnitStruct.Broadcast(Context, Args.S); + OnInsertResultVecI32String.Broadcast(Context, Args.R); return true; } -void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) +void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Type& B) { if (!Conn) { @@ -8358,45 +11554,45 @@ void URemoteReducers::InsertOneUuid(const FSpacetimeDBUuid& U) return; } - FInsertOneUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_one_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOneUuid(ReducerArgs)); } + FInsertTableHoldsTableArgs ReducerArgs(A, B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_table_holds_table"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertTableHoldsTable(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOneUuid(const FReducerEventContext& Context, const UInsertOneUuidReducer* Args) +bool URemoteReducers::InvokeInsertTableHoldsTable(const FReducerEventContext& Context, const UInsertTableHoldsTableReducer* Args) { - if (!OnInsertOneUuid.IsBound()) + if (!OnInsertTableHoldsTable.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); } return false; } - OnInsertOneUuid.Broadcast(Context, Args->U); + OnInsertTableHoldsTable.Broadcast(Context, Args->A, Args->B); return true; } -bool URemoteReducers::InvokeInsertOneUuidWithArgs(const FReducerEventContext& Context, const FInsertOneUuidArgs& Args) +bool URemoteReducers::InvokeInsertTableHoldsTableWithArgs(const FReducerEventContext& Context, const FInsertTableHoldsTableArgs& Args) { - if (!OnInsertOneUuid.IsBound()) + if (!OnInsertTableHoldsTable.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOneUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); } return false; } - OnInsertOneUuid.Broadcast(Context, Args.U); + OnInsertTableHoldsTable.Broadcast(Context, Args.A, Args.B); return true; } -void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptionalEveryPrimitiveStruct& S) +void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) { if (!Conn) { @@ -8404,45 +11600,45 @@ void URemoteReducers::InsertOptionEveryPrimitiveStruct(const FTestClientOptional return; } - FInsertOptionEveryPrimitiveStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionEveryPrimitiveStruct(ReducerArgs)); } + FInsertUniqueBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertOptionEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertUniqueBool(const FReducerEventContext& Context, const UInsertUniqueBoolReducer* Args) { - if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) + if (!OnInsertUniqueBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); } return false; } - OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertUniqueBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertOptionEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertUniqueBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueBoolArgs& Args) { - if (!OnInsertOptionEveryPrimitiveStruct.IsBound()) + if (!OnInsertUniqueBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); } return false; } - OnInsertOptionEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertUniqueBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) +void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -8450,45 +11646,45 @@ void URemoteReducers::InsertOptionI32(const FTestClientOptionalInt32 N) return; } - FInsertOptionI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionI32(ReducerArgs)); } + FInsertUniqueConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionI32(const FReducerEventContext& Context, const UInsertOptionI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueConnectionId(const FReducerEventContext& Context, const UInsertUniqueConnectionIdReducer* Args) { - if (!OnInsertOptionI32.IsBound()) + if (!OnInsertUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); } return false; } - OnInsertOptionI32.Broadcast(Context, Args->N); + OnInsertUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueConnectionIdArgs& Args) { - if (!OnInsertOptionI32.IsBound()) + if (!OnInsertUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); } return false; } - OnInsertOptionI32.Broadcast(Context, Args.N); + OnInsertUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) +void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -8496,45 +11692,45 @@ void URemoteReducers::InsertOptionIdentity(const FTestClientOptionalIdentity& I) return; } - FInsertOptionIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionIdentity(ReducerArgs)); } + FInsertUniqueI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionIdentity(const FReducerEventContext& Context, const UInsertOptionIdentityReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI128(const FReducerEventContext& Context, const UInsertUniqueI128Reducer* Args) { - if (!OnInsertOptionIdentity.IsBound()) + if (!OnInsertUniqueI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); } return false; } - OnInsertOptionIdentity.Broadcast(Context, Args->I); + OnInsertUniqueI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertOptionIdentityArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueI128Args& Args) { - if (!OnInsertOptionIdentity.IsBound()) + if (!OnInsertUniqueI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); } return false; } - OnInsertOptionIdentity.Broadcast(Context, Args.I); + OnInsertUniqueI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum& E) +void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) { if (!Conn) { @@ -8542,45 +11738,45 @@ void URemoteReducers::InsertOptionSimpleEnum(const FTestClientOptionalSimpleEnum return; } - FInsertOptionSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionSimpleEnum(ReducerArgs)); } + FInsertUniqueI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionSimpleEnum(const FReducerEventContext& Context, const UInsertOptionSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI16(const FReducerEventContext& Context, const UInsertUniqueI16Reducer* Args) { - if (!OnInsertOptionSimpleEnum.IsBound()) + if (!OnInsertUniqueI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); } return false; } - OnInsertOptionSimpleEnum.Broadcast(Context, Args->E); + OnInsertUniqueI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertOptionSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueI16Args& Args) { - if (!OnInsertOptionSimpleEnum.IsBound()) + if (!OnInsertUniqueI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); } return false; } - OnInsertOptionSimpleEnum.Broadcast(Context, Args.E); + OnInsertUniqueI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) +void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -8588,45 +11784,45 @@ void URemoteReducers::InsertOptionString(const FTestClientOptionalString& S) return; } - FInsertOptionStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionString(ReducerArgs)); } + FInsertUniqueI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionString(const FReducerEventContext& Context, const UInsertOptionStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI256(const FReducerEventContext& Context, const UInsertUniqueI256Reducer* Args) { - if (!OnInsertOptionString.IsBound()) + if (!OnInsertUniqueI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); } return false; } - OnInsertOptionString.Broadcast(Context, Args->S); + OnInsertUniqueI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionStringWithArgs(const FReducerEventContext& Context, const FInsertOptionStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueI256Args& Args) { - if (!OnInsertOptionString.IsBound()) + if (!OnInsertUniqueI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); } return false; } - OnInsertOptionString.Broadcast(Context, Args.S); + OnInsertUniqueI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) +void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) { if (!Conn) { @@ -8634,45 +11830,45 @@ void URemoteReducers::InsertOptionUuid(const FTestClientOptionalUuid& U) return; } - FInsertOptionUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionUuid(ReducerArgs)); } + FInsertUniqueI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionUuid(const FReducerEventContext& Context, const UInsertOptionUuidReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI32(const FReducerEventContext& Context, const UInsertUniqueI32Reducer* Args) { - if (!OnInsertOptionUuid.IsBound()) + if (!OnInsertUniqueI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); } return false; } - OnInsertOptionUuid.Broadcast(Context, Args->U); + OnInsertUniqueI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertOptionUuidArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueI32Args& Args) { - if (!OnInsertOptionUuid.IsBound()) + if (!OnInsertUniqueI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); } return false; } - OnInsertOptionUuid.Broadcast(Context, Args.U); + OnInsertUniqueI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptionalInt32& V) +void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) { if (!Conn) { @@ -8680,45 +11876,45 @@ void URemoteReducers::InsertOptionVecOptionI32(const FTestClientOptionalVecOptio return; } - FInsertOptionVecOptionI32Args ReducerArgs(V); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_option_vec_option_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertOptionVecOptionI32(ReducerArgs)); } + FInsertUniqueI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertOptionVecOptionI32(const FReducerEventContext& Context, const UInsertOptionVecOptionI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueI64(const FReducerEventContext& Context, const UInsertUniqueI64Reducer* Args) { - if (!OnInsertOptionVecOptionI32.IsBound()) + if (!OnInsertUniqueI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); } return false; } - OnInsertOptionVecOptionI32.Broadcast(Context, Args->V); + OnInsertUniqueI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertOptionVecOptionI32WithArgs(const FReducerEventContext& Context, const FInsertOptionVecOptionI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueI64Args& Args) { - if (!OnInsertOptionVecOptionI32.IsBound()) + if (!OnInsertUniqueI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertOptionVecOptionI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); } return false; } - OnInsertOptionVecOptionI32.Broadcast(Context, Args.V); + OnInsertUniqueI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkBool(const bool B, const int32 Data) +void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) { if (!Conn) { @@ -8726,45 +11922,45 @@ void URemoteReducers::InsertPkBool(const bool B, const int32 Data) return; } - FInsertPkBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkBool(ReducerArgs)); } + FInsertUniqueI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkBool(const FReducerEventContext& Context, const UInsertPkBoolReducer* Args) +bool URemoteReducers::InvokeInsertUniqueI8(const FReducerEventContext& Context, const UInsertUniqueI8Reducer* Args) { - if (!OnInsertPkBool.IsBound()) + if (!OnInsertUniqueI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); } return false; } - OnInsertPkBool.Broadcast(Context, Args->B, Args->Data); + OnInsertUniqueI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkBoolWithArgs(const FReducerEventContext& Context, const FInsertPkBoolArgs& Args) +bool URemoteReducers::InvokeInsertUniqueI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueI8Args& Args) { - if (!OnInsertPkBool.IsBound()) + if (!OnInsertUniqueI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); } return false; } - OnInsertPkBool.Broadcast(Context, Args.B, Args.Data); + OnInsertUniqueI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -8772,45 +11968,45 @@ void URemoteReducers::InsertPkConnectionId(const FSpacetimeDBConnectionId& A, co return; } - FInsertPkConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkConnectionId(ReducerArgs)); } + FInsertUniqueIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkConnectionId(const FReducerEventContext& Context, const UInsertPkConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertUniqueIdentity(const FReducerEventContext& Context, const UInsertUniqueIdentityReducer* Args) { - if (!OnInsertPkConnectionId.IsBound()) + if (!OnInsertUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); } return false; } - OnInsertPkConnectionId.Broadcast(Context, Args->A, Args->Data); + OnInsertUniqueIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertPkConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args) { - if (!OnInsertPkConnectionId.IsBound()) + if (!OnInsertUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); } return false; } - OnInsertPkConnectionId.Broadcast(Context, Args.A, Args.Data); + OnInsertUniqueIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -8818,45 +12014,45 @@ void URemoteReducers::InsertPkI128(const FSpacetimeDBInt128& N, const int32 Data return; } - FInsertPkI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI128(ReducerArgs)); } + FInsertUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI128(const FReducerEventContext& Context, const UInsertPkI128Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionBool(const FReducerEventContext& Context, const UInsertUniqueOptionBoolReducer* Args) { - if (!OnInsertPkI128.IsBound()) + if (!OnInsertUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionBool")); } return false; } - OnInsertPkI128.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI128WithArgs(const FReducerEventContext& Context, const FInsertPkI128Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionBoolArgs& Args) { - if (!OnInsertPkI128.IsBound()) + if (!OnInsertUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionBool")); } return false; } - OnInsertPkI128.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -8864,45 +12060,45 @@ void URemoteReducers::InsertPkI16(const int16 N, const int32 Data) return; } - FInsertPkI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI16(ReducerArgs)); } + FInsertUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI16(const FReducerEventContext& Context, const UInsertPkI16Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionConnectionId(const FReducerEventContext& Context, const UInsertUniqueOptionConnectionIdReducer* Args) { - if (!OnInsertPkI16.IsBound()) + if (!OnInsertUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionConnectionId")); } return false; } - OnInsertPkI16.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI16WithArgs(const FReducerEventContext& Context, const FInsertPkI16Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionConnectionIdArgs& Args) { - if (!OnInsertPkI16.IsBound()) + if (!OnInsertUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionConnectionId")); } return false; } - OnInsertPkI16.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -8910,45 +12106,45 @@ void URemoteReducers::InsertPkI256(const FSpacetimeDBInt256& N, const int32 Data return; } - FInsertPkI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI256(ReducerArgs)); } + FInsertUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI256(const FReducerEventContext& Context, const UInsertPkI256Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI128(const FReducerEventContext& Context, const UInsertUniqueOptionI128Reducer* Args) { - if (!OnInsertPkI256.IsBound()) + if (!OnInsertUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI128")); } return false; } - OnInsertPkI256.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI256WithArgs(const FReducerEventContext& Context, const FInsertPkI256Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI128Args& Args) { - if (!OnInsertPkI256.IsBound()) + if (!OnInsertUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI128")); } return false; } - OnInsertPkI256.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -8956,45 +12152,45 @@ void URemoteReducers::InsertPkI32(const int32 N, const int32 Data) return; } - FInsertPkI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI32(ReducerArgs)); } + FInsertUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI32(const FReducerEventContext& Context, const UInsertPkI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI16(const FReducerEventContext& Context, const UInsertUniqueOptionI16Reducer* Args) { - if (!OnInsertPkI32.IsBound()) + if (!OnInsertUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI16")); } return false; } - OnInsertPkI32.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI32WithArgs(const FReducerEventContext& Context, const FInsertPkI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI16Args& Args) { - if (!OnInsertPkI32.IsBound()) + if (!OnInsertUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI16")); } return false; } - OnInsertPkI32.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -9002,45 +12198,45 @@ void URemoteReducers::InsertPkI64(const int64 N, const int32 Data) return; } - FInsertPkI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI64(ReducerArgs)); } + FInsertUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI64(const FReducerEventContext& Context, const UInsertPkI64Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI256(const FReducerEventContext& Context, const UInsertUniqueOptionI256Reducer* Args) { - if (!OnInsertPkI64.IsBound()) + if (!OnInsertUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI256")); } return false; } - OnInsertPkI64.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI64WithArgs(const FReducerEventContext& Context, const FInsertPkI64Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI256Args& Args) { - if (!OnInsertPkI64.IsBound()) + if (!OnInsertUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI256")); } return false; } - OnInsertPkI64.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -9048,45 +12244,45 @@ void URemoteReducers::InsertPkI8(const int8 N, const int32 Data) return; } - FInsertPkI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkI8(ReducerArgs)); } + FInsertUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkI8(const FReducerEventContext& Context, const UInsertPkI8Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI32(const FReducerEventContext& Context, const UInsertUniqueOptionI32Reducer* Args) { - if (!OnInsertPkI8.IsBound()) + if (!OnInsertUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI32")); } return false; } - OnInsertPkI8.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkI8WithArgs(const FReducerEventContext& Context, const FInsertPkI8Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI32Args& Args) { - if (!OnInsertPkI8.IsBound()) + if (!OnInsertUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI32")); } return false; } - OnInsertPkI8.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::InsertUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -9094,45 +12290,45 @@ void URemoteReducers::InsertPkIdentity(const FSpacetimeDBIdentity& I, const int3 return; } - FInsertPkIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkIdentity(ReducerArgs)); } + FInsertUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkIdentity(const FReducerEventContext& Context, const UInsertPkIdentityReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI64(const FReducerEventContext& Context, const UInsertUniqueOptionI64Reducer* Args) { - if (!OnInsertPkIdentity.IsBound()) + if (!OnInsertUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI64")); } return false; } - OnInsertPkIdentity.Broadcast(Context, Args->I, Args->Data); + OnInsertUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkIdentityWithArgs(const FReducerEventContext& Context, const FInsertPkIdentityArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI64Args& Args) { - if (!OnInsertPkIdentity.IsBound()) + if (!OnInsertUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI64")); } return false; } - OnInsertPkIdentity.Broadcast(Context, Args.I, Args.Data); + OnInsertUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 Data) +void URemoteReducers::InsertUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -9140,45 +12336,45 @@ void URemoteReducers::InsertPkSimpleEnum(const ESimpleEnumType& A, const int32 D return; } - FInsertPkSimpleEnumArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkSimpleEnum(ReducerArgs)); } + FInsertUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkSimpleEnum(const FReducerEventContext& Context, const UInsertPkSimpleEnumReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionI8(const FReducerEventContext& Context, const UInsertUniqueOptionI8Reducer* Args) { - if (!OnInsertPkSimpleEnum.IsBound()) + if (!OnInsertUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI8")); } return false; } - OnInsertPkSimpleEnum.Broadcast(Context, Args->A, Args->Data); + OnInsertUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertPkSimpleEnumArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI8Args& Args) { - if (!OnInsertPkSimpleEnum.IsBound()) + if (!OnInsertUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionI8")); } return false; } - OnInsertPkSimpleEnum.Broadcast(Context, Args.A, Args.Data); + OnInsertUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkString(const FString& S, const int32 Data) +void URemoteReducers::InsertUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -9186,45 +12382,45 @@ void URemoteReducers::InsertPkString(const FString& S, const int32 Data) return; } - FInsertPkStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkString(ReducerArgs)); } + FInsertUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkString(const FReducerEventContext& Context, const UInsertPkStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionIdentity(const FReducerEventContext& Context, const UInsertUniqueOptionIdentityReducer* Args) { - if (!OnInsertPkString.IsBound()) + if (!OnInsertUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionIdentity")); } return false; } - OnInsertPkString.Broadcast(Context, Args->S, Args->Data); + OnInsertUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkStringWithArgs(const FReducerEventContext& Context, const FInsertPkStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionIdentityArgs& Args) { - if (!OnInsertPkString.IsBound()) + if (!OnInsertUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionIdentity")); } return false; } - OnInsertPkString.Broadcast(Context, Args.S, Args.Data); + OnInsertUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -9232,45 +12428,45 @@ void URemoteReducers::InsertPkU128(const FSpacetimeDBUInt128& N, const int32 Dat return; } - FInsertPkU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU128(ReducerArgs)); } + FInsertUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU128(const FReducerEventContext& Context, const UInsertPkU128Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionString(const FReducerEventContext& Context, const UInsertUniqueOptionStringReducer* Args) { - if (!OnInsertPkU128.IsBound()) + if (!OnInsertUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionString")); } return false; } - OnInsertPkU128.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU128WithArgs(const FReducerEventContext& Context, const FInsertPkU128Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionStringArgs& Args) { - if (!OnInsertPkU128.IsBound()) + if (!OnInsertUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionString")); } return false; } - OnInsertPkU128.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -9278,45 +12474,45 @@ void URemoteReducers::InsertPkU16(const uint16 N, const int32 Data) return; } - FInsertPkU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU16(ReducerArgs)); } + FInsertUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU16(const FReducerEventContext& Context, const UInsertPkU16Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU128(const FReducerEventContext& Context, const UInsertUniqueOptionU128Reducer* Args) { - if (!OnInsertPkU16.IsBound()) + if (!OnInsertUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU128")); } return false; } - OnInsertPkU16.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU16WithArgs(const FReducerEventContext& Context, const FInsertPkU16Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU128Args& Args) { - if (!OnInsertPkU16.IsBound()) + if (!OnInsertUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU128")); } return false; } - OnInsertPkU16.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -9324,45 +12520,45 @@ void URemoteReducers::InsertPkU256(const FSpacetimeDBUInt256& N, const int32 Dat return; } - FInsertPkU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU256(ReducerArgs)); } + FInsertUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU256(const FReducerEventContext& Context, const UInsertPkU256Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU16(const FReducerEventContext& Context, const UInsertUniqueOptionU16Reducer* Args) { - if (!OnInsertPkU256.IsBound()) + if (!OnInsertUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU16")); } return false; } - OnInsertPkU256.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU256WithArgs(const FReducerEventContext& Context, const FInsertPkU256Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU16Args& Args) { - if (!OnInsertPkU256.IsBound()) + if (!OnInsertUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU16")); } return false; } - OnInsertPkU256.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -9370,45 +12566,45 @@ void URemoteReducers::InsertPkU32(const uint32 N, const int32 Data) return; } - FInsertPkU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32(ReducerArgs)); } + FInsertUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU32(const FReducerEventContext& Context, const UInsertPkU32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU256(const FReducerEventContext& Context, const UInsertUniqueOptionU256Reducer* Args) { - if (!OnInsertPkU32.IsBound()) + if (!OnInsertUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU256")); } return false; } - OnInsertPkU32.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU32WithArgs(const FReducerEventContext& Context, const FInsertPkU32Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU256Args& Args) { - if (!OnInsertPkU32.IsBound()) + if (!OnInsertUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU256")); } return false; } - OnInsertPkU32.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -9416,45 +12612,45 @@ void URemoteReducers::InsertPkU32Two(const uint32 N, const int32 Data) return; } - FInsertPkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU32Two(ReducerArgs)); } + FInsertUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU32Two(const FReducerEventContext& Context, const UInsertPkU32TwoReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU32(const FReducerEventContext& Context, const UInsertUniqueOptionU32Reducer* Args) { - if (!OnInsertPkU32Two.IsBound()) + if (!OnInsertUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU32")); } return false; } - OnInsertPkU32Two.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU32TwoWithArgs(const FReducerEventContext& Context, const FInsertPkU32TwoArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU32Args& Args) { - if (!OnInsertPkU32Two.IsBound()) + if (!OnInsertUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU32")); } return false; } - OnInsertPkU32Two.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -9462,45 +12658,45 @@ void URemoteReducers::InsertPkU64(const uint64 N, const int32 Data) return; } - FInsertPkU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU64(ReducerArgs)); } + FInsertUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU64(const FReducerEventContext& Context, const UInsertPkU64Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU64(const FReducerEventContext& Context, const UInsertUniqueOptionU64Reducer* Args) { - if (!OnInsertPkU64.IsBound()) + if (!OnInsertUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU64")); } return false; } - OnInsertPkU64.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU64WithArgs(const FReducerEventContext& Context, const FInsertPkU64Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU64Args& Args) { - if (!OnInsertPkU64.IsBound()) + if (!OnInsertUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU64")); } return false; } - OnInsertPkU64.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) +void URemoteReducers::InsertUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -9508,45 +12704,45 @@ void URemoteReducers::InsertPkU8(const uint8 N, const int32 Data) return; } - FInsertPkU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkU8(ReducerArgs)); } + FInsertUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkU8(const FReducerEventContext& Context, const UInsertPkU8Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionU8(const FReducerEventContext& Context, const UInsertUniqueOptionU8Reducer* Args) { - if (!OnInsertPkU8.IsBound()) + if (!OnInsertUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU8")); } return false; } - OnInsertPkU8.Broadcast(Context, Args->N, Args->Data); + OnInsertUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkU8WithArgs(const FReducerEventContext& Context, const FInsertPkU8Args& Args) +bool URemoteReducers::InvokeInsertUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU8Args& Args) { - if (!OnInsertPkU8.IsBound()) + if (!OnInsertUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionU8")); } return false; } - OnInsertPkU8.Broadcast(Context, Args.N, Args.Data); + OnInsertUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::InsertUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -9554,45 +12750,45 @@ void URemoteReducers::InsertPkUuid(const FSpacetimeDBUuid& U, const int32 Data) return; } - FInsertPkUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPkUuid(ReducerArgs)); } + FInsertUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPkUuid(const FReducerEventContext& Context, const UInsertPkUuidReducer* Args) +bool URemoteReducers::InvokeInsertUniqueOptionUuid(const FReducerEventContext& Context, const UInsertUniqueOptionUuidReducer* Args) { - if (!OnInsertPkUuid.IsBound()) + if (!OnInsertUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionUuid")); } return false; } - OnInsertPkUuid.Broadcast(Context, Args->U, Args->Data); + OnInsertUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPkUuidWithArgs(const FReducerEventContext& Context, const FInsertPkUuidArgs& Args) +bool URemoteReducers::InvokeInsertUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionUuidArgs& Args) { - if (!OnInsertPkUuid.IsBound()) + if (!OnInsertUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueOptionUuid")); } return false; } - OnInsertPkUuid.Broadcast(Context, Args.U, Args.Data); + OnInsertUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& S) +void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) { if (!Conn) { @@ -9600,45 +12796,45 @@ void URemoteReducers::InsertPrimitivesAsStrings(const FEveryPrimitiveStructType& return; } - FInsertPrimitivesAsStringsArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_primitives_as_strings"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertPrimitivesAsStrings(ReducerArgs)); } + FInsertUniqueStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertPrimitivesAsStrings(const FReducerEventContext& Context, const UInsertPrimitivesAsStringsReducer* Args) +bool URemoteReducers::InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args) { - if (!OnInsertPrimitivesAsStrings.IsBound()) + if (!OnInsertUniqueString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); } return false; } - OnInsertPrimitivesAsStrings.Broadcast(Context, Args->S); + OnInsertUniqueString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertPrimitivesAsStringsWithArgs(const FReducerEventContext& Context, const FInsertPrimitivesAsStringsArgs& Args) +bool URemoteReducers::InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args) { - if (!OnInsertPrimitivesAsStrings.IsBound()) + if (!OnInsertUniqueString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertPrimitivesAsStrings")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); } return false; } - OnInsertPrimitivesAsStrings.Broadcast(Context, Args.S); + OnInsertUniqueString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientResultEveryPrimitiveStructString& R) +void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -9646,45 +12842,45 @@ void URemoteReducers::InsertResultEveryPrimitiveStructString(const FTestClientRe return; } - FInsertResultEveryPrimitiveStructStringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_every_primitive_struct_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultEveryPrimitiveStructString(ReducerArgs)); } + FInsertUniqueU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructString(const FReducerEventContext& Context, const UInsertResultEveryPrimitiveStructStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args) { - if (!OnInsertResultEveryPrimitiveStructString.IsBound()) + if (!OnInsertUniqueU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); } return false; } - OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args->R); + OnInsertUniqueU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultEveryPrimitiveStructStringWithArgs(const FReducerEventContext& Context, const FInsertResultEveryPrimitiveStructStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args) { - if (!OnInsertResultEveryPrimitiveStructString.IsBound()) + if (!OnInsertUniqueU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultEveryPrimitiveStructString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); } return false; } - OnInsertResultEveryPrimitiveStructString.Broadcast(Context, Args.R); + OnInsertUniqueU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& R) +void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -9692,45 +12888,45 @@ void URemoteReducers::InsertResultI32String(const FTestClientResultInt32String& return; } - FInsertResultI32StringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_i_32_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultI32String(ReducerArgs)); } + FInsertUniqueU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultI32String(const FReducerEventContext& Context, const UInsertResultI32StringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args) { - if (!OnInsertResultI32String.IsBound()) + if (!OnInsertUniqueU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); } return false; } - OnInsertResultI32String.Broadcast(Context, Args->R); + OnInsertUniqueU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultI32StringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args) { - if (!OnInsertResultI32String.IsBound()) + if (!OnInsertUniqueU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); } return false; } - OnInsertResultI32String.Broadcast(Context, Args.R); + OnInsertUniqueU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentityString& R) +void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -9738,45 +12934,45 @@ void URemoteReducers::InsertResultIdentityString(const FTestClientResultIdentity return; } - FInsertResultIdentityStringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_identity_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultIdentityString(ReducerArgs)); } + FInsertUniqueU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultIdentityString(const FReducerEventContext& Context, const UInsertResultIdentityStringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args) { - if (!OnInsertResultIdentityString.IsBound()) + if (!OnInsertUniqueU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); } return false; } - OnInsertResultIdentityString.Broadcast(Context, Args->R); + OnInsertUniqueU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultIdentityStringWithArgs(const FReducerEventContext& Context, const FInsertResultIdentityStringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args) { - if (!OnInsertResultIdentityString.IsBound()) + if (!OnInsertUniqueU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultIdentityString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); } return false; } - OnInsertResultIdentityString.Broadcast(Context, Args.R); + OnInsertUniqueU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnumInt32& R) +void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -9784,45 +12980,45 @@ void URemoteReducers::InsertResultSimpleEnumI32(const FTestClientResultSimpleEnu return; } - FInsertResultSimpleEnumI32Args ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_simple_enum_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultSimpleEnumI32(ReducerArgs)); } + FInsertUniqueU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultSimpleEnumI32(const FReducerEventContext& Context, const UInsertResultSimpleEnumI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args) { - if (!OnInsertResultSimpleEnumI32.IsBound()) + if (!OnInsertUniqueU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); } return false; } - OnInsertResultSimpleEnumI32.Broadcast(Context, Args->R); + OnInsertUniqueU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultSimpleEnumI32WithArgs(const FReducerEventContext& Context, const FInsertResultSimpleEnumI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args) { - if (!OnInsertResultSimpleEnumI32.IsBound()) + if (!OnInsertUniqueU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultSimpleEnumI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); } return false; } - OnInsertResultSimpleEnumI32.Broadcast(Context, Args.R); + OnInsertUniqueU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& R) +void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk) { if (!Conn) { @@ -9830,45 +13026,45 @@ void URemoteReducers::InsertResultStringI32(const FTestClientResultStringInt32& return; } - FInsertResultStringI32Args ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_string_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultStringI32(ReducerArgs)); } + FInsertUniqueU32UpdatePkU32Args ReducerArgs(N, DUnique, DPk); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32_update_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32UpdatePkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultStringI32(const FReducerEventContext& Context, const UInsertResultStringI32Reducer* Args) +bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args) { - if (!OnInsertResultStringI32.IsBound()) + if (!OnInsertUniqueU32UpdatePkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); } return false; } - OnInsertResultStringI32.Broadcast(Context, Args->R); + OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args->N, Args->DUnique, Args->DPk); return true; } -bool URemoteReducers::InvokeInsertResultStringI32WithArgs(const FReducerEventContext& Context, const FInsertResultStringI32Args& Args) +bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args) { - if (!OnInsertResultStringI32.IsBound()) + if (!OnInsertUniqueU32UpdatePkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultStringI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); } return false; } - OnInsertResultStringI32.Broadcast(Context, Args.R); + OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args.N, Args.DUnique, Args.DPk); return true; } -void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32String& R) +void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -9876,45 +13072,45 @@ void URemoteReducers::InsertResultVecI32String(const FTestClientResultVecInt32St return; } - FInsertResultVecI32StringArgs ReducerArgs(R); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_result_vec_i_32_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertResultVecI32String(ReducerArgs)); } + FInsertUniqueU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertResultVecI32String(const FReducerEventContext& Context, const UInsertResultVecI32StringReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args) { - if (!OnInsertResultVecI32String.IsBound()) + if (!OnInsertUniqueU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); } return false; } - OnInsertResultVecI32String.Broadcast(Context, Args->R); + OnInsertUniqueU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertResultVecI32StringWithArgs(const FReducerEventContext& Context, const FInsertResultVecI32StringArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args) { - if (!OnInsertResultVecI32String.IsBound()) + if (!OnInsertUniqueU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertResultVecI32String")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); } return false; } - OnInsertResultVecI32String.Broadcast(Context, Args.R); + OnInsertUniqueU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Type& B) +void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -9922,45 +13118,45 @@ void URemoteReducers::InsertTableHoldsTable(const FOneU8Type& A, const FVecU8Typ return; } - FInsertTableHoldsTableArgs ReducerArgs(A, B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_table_holds_table"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertTableHoldsTable(ReducerArgs)); } + FInsertUniqueU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertTableHoldsTable(const FReducerEventContext& Context, const UInsertTableHoldsTableReducer* Args) +bool URemoteReducers::InvokeInsertUniqueU8(const FReducerEventContext& Context, const UInsertUniqueU8Reducer* Args) { - if (!OnInsertTableHoldsTable.IsBound()) + if (!OnInsertUniqueU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); } return false; } - OnInsertTableHoldsTable.Broadcast(Context, Args->A, Args->B); + OnInsertUniqueU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertTableHoldsTableWithArgs(const FReducerEventContext& Context, const FInsertTableHoldsTableArgs& Args) +bool URemoteReducers::InvokeInsertUniqueU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueU8Args& Args) { - if (!OnInsertTableHoldsTable.IsBound()) + if (!OnInsertUniqueU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertTableHoldsTable")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); } return false; } - OnInsertTableHoldsTable.Broadcast(Context, Args.A, Args.B); + OnInsertUniqueU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) +void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -9968,45 +13164,45 @@ void URemoteReducers::InsertUniqueBool(const bool B, const int32 Data) return; } - FInsertUniqueBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueBool(ReducerArgs)); } + FInsertUniqueUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueBool(const FReducerEventContext& Context, const UInsertUniqueBoolReducer* Args) +bool URemoteReducers::InvokeInsertUniqueUuid(const FReducerEventContext& Context, const UInsertUniqueUuidReducer* Args) { - if (!OnInsertUniqueBool.IsBound()) + if (!OnInsertUniqueUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); } return false; } - OnInsertUniqueBool.Broadcast(Context, Args->B, Args->Data); + OnInsertUniqueUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeInsertUniqueBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueBoolArgs& Args) +bool URemoteReducers::InvokeInsertUniqueUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueUuidArgs& Args) { - if (!OnInsertUniqueBool.IsBound()) + if (!OnInsertUniqueUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); } return false; } - OnInsertUniqueBool.Broadcast(Context, Args.B, Args.Data); + OnInsertUniqueUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity& Identity) { if (!Conn) { @@ -10014,45 +13210,45 @@ void URemoteReducers::InsertUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FInsertUniqueConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueConnectionId(ReducerArgs)); } + FInsertUserArgs ReducerArgs(Name, Identity); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_user"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUser(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueConnectionId(const FReducerEventContext& Context, const UInsertUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertUser(const FReducerEventContext& Context, const UInsertUserReducer* Args) { - if (!OnInsertUniqueConnectionId.IsBound()) + if (!OnInsertUser.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); } return false; } - OnInsertUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); + OnInsertUser.Broadcast(Context, Args->Name, Args->Identity); return true; } -bool URemoteReducers::InvokeInsertUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertUserWithArgs(const FReducerEventContext& Context, const FInsertUserArgs& Args) { - if (!OnInsertUniqueConnectionId.IsBound()) + if (!OnInsertUser.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); } return false; } - OnInsertUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); + OnInsertUser.Broadcast(Context, Args.Name, Args.Identity); return true; } -void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::InsertVecBool(const TArray& B) { if (!Conn) { @@ -10060,45 +13256,45 @@ void URemoteReducers::InsertUniqueI128(const FSpacetimeDBInt128& N, const int32 return; } - FInsertUniqueI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI128(ReducerArgs)); } + FInsertVecBoolArgs ReducerArgs(B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI128(const FReducerEventContext& Context, const UInsertUniqueI128Reducer* Args) +bool URemoteReducers::InvokeInsertVecBool(const FReducerEventContext& Context, const UInsertVecBoolReducer* Args) { - if (!OnInsertUniqueI128.IsBound()) + if (!OnInsertVecBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); } return false; } - OnInsertUniqueI128.Broadcast(Context, Args->N, Args->Data); + OnInsertVecBool.Broadcast(Context, Args->B); return true; } -bool URemoteReducers::InvokeInsertUniqueI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueI128Args& Args) +bool URemoteReducers::InvokeInsertVecBoolWithArgs(const FReducerEventContext& Context, const FInsertVecBoolArgs& Args) { - if (!OnInsertUniqueI128.IsBound()) + if (!OnInsertVecBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); } return false; } - OnInsertUniqueI128.Broadcast(Context, Args.N, Args.Data); + OnInsertVecBool.Broadcast(Context, Args.B); return true; } -void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) +void URemoteReducers::InsertVecByteStruct(const TArray& S) { if (!Conn) { @@ -10106,45 +13302,45 @@ void URemoteReducers::InsertUniqueI16(const int16 N, const int32 Data) return; } - FInsertUniqueI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI16(ReducerArgs)); } + FInsertVecByteStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_byte_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecByteStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI16(const FReducerEventContext& Context, const UInsertUniqueI16Reducer* Args) +bool URemoteReducers::InvokeInsertVecByteStruct(const FReducerEventContext& Context, const UInsertVecByteStructReducer* Args) { - if (!OnInsertUniqueI16.IsBound()) + if (!OnInsertVecByteStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); } return false; } - OnInsertUniqueI16.Broadcast(Context, Args->N, Args->Data); + OnInsertVecByteStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueI16Args& Args) +bool URemoteReducers::InvokeInsertVecByteStructWithArgs(const FReducerEventContext& Context, const FInsertVecByteStructArgs& Args) { - if (!OnInsertUniqueI16.IsBound()) + if (!OnInsertVecByteStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); } return false; } - OnInsertUniqueI16.Broadcast(Context, Args.N, Args.Data); + OnInsertVecByteStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::InsertVecConnectionId(const TArray& A) { if (!Conn) { @@ -10152,45 +13348,45 @@ void URemoteReducers::InsertUniqueI256(const FSpacetimeDBInt256& N, const int32 return; } - FInsertUniqueI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI256(ReducerArgs)); } + FInsertVecConnectionIdArgs ReducerArgs(A); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI256(const FReducerEventContext& Context, const UInsertUniqueI256Reducer* Args) +bool URemoteReducers::InvokeInsertVecConnectionId(const FReducerEventContext& Context, const UInsertVecConnectionIdReducer* Args) { - if (!OnInsertUniqueI256.IsBound()) + if (!OnInsertVecConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); } return false; } - OnInsertUniqueI256.Broadcast(Context, Args->N, Args->Data); + OnInsertVecConnectionId.Broadcast(Context, Args->A); return true; } -bool URemoteReducers::InvokeInsertUniqueI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueI256Args& Args) +bool URemoteReducers::InvokeInsertVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertVecConnectionIdArgs& Args) { - if (!OnInsertUniqueI256.IsBound()) + if (!OnInsertVecConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); } return false; } - OnInsertUniqueI256.Broadcast(Context, Args.N, Args.Data); + OnInsertVecConnectionId.Broadcast(Context, Args.A); return true; } -void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) +void URemoteReducers::InsertVecEnumWithPayload(const TArray& E) { if (!Conn) { @@ -10198,45 +13394,45 @@ void URemoteReducers::InsertUniqueI32(const int32 N, const int32 Data) return; } - FInsertUniqueI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI32(ReducerArgs)); } + FInsertVecEnumWithPayloadArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_enum_with_payload"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEnumWithPayload(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI32(const FReducerEventContext& Context, const UInsertUniqueI32Reducer* Args) +bool URemoteReducers::InvokeInsertVecEnumWithPayload(const FReducerEventContext& Context, const UInsertVecEnumWithPayloadReducer* Args) { - if (!OnInsertUniqueI32.IsBound()) + if (!OnInsertVecEnumWithPayload.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); } return false; } - OnInsertUniqueI32.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEnumWithPayload.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertUniqueI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueI32Args& Args) +bool URemoteReducers::InvokeInsertVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertVecEnumWithPayloadArgs& Args) { - if (!OnInsertUniqueI32.IsBound()) + if (!OnInsertVecEnumWithPayload.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); } return false; } - OnInsertUniqueI32.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEnumWithPayload.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) +void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArray& S) { if (!Conn) { @@ -10244,45 +13440,45 @@ void URemoteReducers::InsertUniqueI64(const int64 N, const int32 Data) return; } - FInsertUniqueI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI64(ReducerArgs)); } + FInsertVecEveryPrimitiveStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_primitive_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryPrimitiveStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI64(const FReducerEventContext& Context, const UInsertUniqueI64Reducer* Args) +bool URemoteReducers::InvokeInsertVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertVecEveryPrimitiveStructReducer* Args) { - if (!OnInsertUniqueI64.IsBound()) + if (!OnInsertVecEveryPrimitiveStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); } return false; } - OnInsertUniqueI64.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueI64Args& Args) +bool URemoteReducers::InvokeInsertVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryPrimitiveStructArgs& Args) { - if (!OnInsertUniqueI64.IsBound()) + if (!OnInsertVecEveryPrimitiveStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); } return false; } - OnInsertUniqueI64.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) +void URemoteReducers::InsertVecEveryVecStruct(const TArray& S) { if (!Conn) { @@ -10290,45 +13486,45 @@ void URemoteReducers::InsertUniqueI8(const int8 N, const int32 Data) return; } - FInsertUniqueI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueI8(ReducerArgs)); } + FInsertVecEveryVecStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_vec_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryVecStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueI8(const FReducerEventContext& Context, const UInsertUniqueI8Reducer* Args) +bool URemoteReducers::InvokeInsertVecEveryVecStruct(const FReducerEventContext& Context, const UInsertVecEveryVecStructReducer* Args) { - if (!OnInsertUniqueI8.IsBound()) + if (!OnInsertVecEveryVecStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); } return false; } - OnInsertUniqueI8.Broadcast(Context, Args->N, Args->Data); + OnInsertVecEveryVecStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUniqueI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueI8Args& Args) +bool URemoteReducers::InvokeInsertVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryVecStructArgs& Args) { - if (!OnInsertUniqueI8.IsBound()) + if (!OnInsertVecEveryVecStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); } return false; } - OnInsertUniqueI8.Broadcast(Context, Args.N, Args.Data); + OnInsertVecEveryVecStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::InsertVecF32(const TArray& F) { if (!Conn) { @@ -10336,45 +13532,45 @@ void URemoteReducers::InsertUniqueIdentity(const FSpacetimeDBIdentity& I, const return; } - FInsertUniqueIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueIdentity(ReducerArgs)); } + FInsertVecF32Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueIdentity(const FReducerEventContext& Context, const UInsertUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeInsertVecF32(const FReducerEventContext& Context, const UInsertVecF32Reducer* Args) { - if (!OnInsertUniqueIdentity.IsBound()) + if (!OnInsertVecF32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); } return false; } - OnInsertUniqueIdentity.Broadcast(Context, Args->I, Args->Data); + OnInsertVecF32.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeInsertVecF32WithArgs(const FReducerEventContext& Context, const FInsertVecF32Args& Args) { - if (!OnInsertUniqueIdentity.IsBound()) + if (!OnInsertVecF32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); } return false; } - OnInsertUniqueIdentity.Broadcast(Context, Args.I, Args.Data); + OnInsertVecF32.Broadcast(Context, Args.F); return true; } -void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) +void URemoteReducers::InsertVecF64(const TArray& F) { if (!Conn) { @@ -10382,45 +13578,45 @@ void URemoteReducers::InsertUniqueString(const FString& S, const int32 Data) return; } - FInsertUniqueStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueString(ReducerArgs)); } + FInsertVecF64Args ReducerArgs(F); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args) +bool URemoteReducers::InvokeInsertVecF64(const FReducerEventContext& Context, const UInsertVecF64Reducer* Args) { - if (!OnInsertUniqueString.IsBound()) + if (!OnInsertVecF64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); } return false; } - OnInsertUniqueString.Broadcast(Context, Args->S, Args->Data); + OnInsertVecF64.Broadcast(Context, Args->F); return true; } -bool URemoteReducers::InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args) +bool URemoteReducers::InvokeInsertVecF64WithArgs(const FReducerEventContext& Context, const FInsertVecF64Args& Args) { - if (!OnInsertUniqueString.IsBound()) + if (!OnInsertVecF64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); } return false; } - OnInsertUniqueString.Broadcast(Context, Args.S, Args.Data); + OnInsertVecF64.Broadcast(Context, Args.F); return true; } -void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::InsertVecI128(const TArray& N) { if (!Conn) { @@ -10428,45 +13624,45 @@ void URemoteReducers::InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 return; } - FInsertUniqueU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU128(ReducerArgs)); } + FInsertVecI128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args) +bool URemoteReducers::InvokeInsertVecI128(const FReducerEventContext& Context, const UInsertVecI128Reducer* Args) { - if (!OnInsertUniqueU128.IsBound()) + if (!OnInsertVecI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); } return false; } - OnInsertUniqueU128.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args) +bool URemoteReducers::InvokeInsertVecI128WithArgs(const FReducerEventContext& Context, const FInsertVecI128Args& Args) { - if (!OnInsertUniqueU128.IsBound()) + if (!OnInsertVecI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); } return false; } - OnInsertUniqueU128.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) +void URemoteReducers::InsertVecI16(const TArray& N) { if (!Conn) { @@ -10474,45 +13670,45 @@ void URemoteReducers::InsertUniqueU16(const uint16 N, const int32 Data) return; } - FInsertUniqueU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU16(ReducerArgs)); } + FInsertVecI16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args) +bool URemoteReducers::InvokeInsertVecI16(const FReducerEventContext& Context, const UInsertVecI16Reducer* Args) { - if (!OnInsertUniqueU16.IsBound()) + if (!OnInsertVecI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); } return false; } - OnInsertUniqueU16.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args) +bool URemoteReducers::InvokeInsertVecI16WithArgs(const FReducerEventContext& Context, const FInsertVecI16Args& Args) { - if (!OnInsertUniqueU16.IsBound()) + if (!OnInsertVecI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); } return false; } - OnInsertUniqueU16.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::InsertVecI256(const TArray& N) { if (!Conn) { @@ -10520,45 +13716,45 @@ void URemoteReducers::InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 return; } - FInsertUniqueU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU256(ReducerArgs)); } + FInsertVecI256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args) +bool URemoteReducers::InvokeInsertVecI256(const FReducerEventContext& Context, const UInsertVecI256Reducer* Args) { - if (!OnInsertUniqueU256.IsBound()) + if (!OnInsertVecI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); } return false; } - OnInsertUniqueU256.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args) +bool URemoteReducers::InvokeInsertVecI256WithArgs(const FReducerEventContext& Context, const FInsertVecI256Args& Args) { - if (!OnInsertUniqueU256.IsBound()) + if (!OnInsertVecI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); } return false; } - OnInsertUniqueU256.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) +void URemoteReducers::InsertVecI32(const TArray& N) { if (!Conn) { @@ -10566,45 +13762,45 @@ void URemoteReducers::InsertUniqueU32(const uint32 N, const int32 Data) return; } - FInsertUniqueU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32(ReducerArgs)); } + FInsertVecI32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args) +bool URemoteReducers::InvokeInsertVecI32(const FReducerEventContext& Context, const UInsertVecI32Reducer* Args) { - if (!OnInsertUniqueU32.IsBound()) + if (!OnInsertVecI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); } return false; } - OnInsertUniqueU32.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args) +bool URemoteReducers::InvokeInsertVecI32WithArgs(const FReducerEventContext& Context, const FInsertVecI32Args& Args) { - if (!OnInsertUniqueU32.IsBound()) + if (!OnInsertVecI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); } return false; } - OnInsertUniqueU32.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk) +void URemoteReducers::InsertVecI64(const TArray& N) { if (!Conn) { @@ -10612,45 +13808,45 @@ void URemoteReducers::InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUn return; } - FInsertUniqueU32UpdatePkU32Args ReducerArgs(N, DUnique, DPk); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_32_update_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU32UpdatePkU32(ReducerArgs)); } + FInsertVecI64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args) +bool URemoteReducers::InvokeInsertVecI64(const FReducerEventContext& Context, const UInsertVecI64Reducer* Args) { - if (!OnInsertUniqueU32UpdatePkU32.IsBound()) + if (!OnInsertVecI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); } return false; } - OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args->N, Args->DUnique, Args->DPk); + OnInsertVecI64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args) +bool URemoteReducers::InvokeInsertVecI64WithArgs(const FReducerEventContext& Context, const FInsertVecI64Args& Args) { - if (!OnInsertUniqueU32UpdatePkU32.IsBound()) + if (!OnInsertVecI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU32UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); } return false; } - OnInsertUniqueU32UpdatePkU32.Broadcast(Context, Args.N, Args.DUnique, Args.DPk); + OnInsertVecI64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) +void URemoteReducers::InsertVecI8(const TArray& N) { if (!Conn) { @@ -10658,45 +13854,45 @@ void URemoteReducers::InsertUniqueU64(const uint64 N, const int32 Data) return; } - FInsertUniqueU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU64(ReducerArgs)); } + FInsertVecI8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args) +bool URemoteReducers::InvokeInsertVecI8(const FReducerEventContext& Context, const UInsertVecI8Reducer* Args) { - if (!OnInsertUniqueU64.IsBound()) + if (!OnInsertVecI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); } return false; } - OnInsertUniqueU64.Broadcast(Context, Args->N, Args->Data); + OnInsertVecI8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args) +bool URemoteReducers::InvokeInsertVecI8WithArgs(const FReducerEventContext& Context, const FInsertVecI8Args& Args) { - if (!OnInsertUniqueU64.IsBound()) + if (!OnInsertVecI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); } return false; } - OnInsertUniqueU64.Broadcast(Context, Args.N, Args.Data); + OnInsertVecI8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) +void URemoteReducers::InsertVecIdentity(const TArray& I) { if (!Conn) { @@ -10704,45 +13900,45 @@ void URemoteReducers::InsertUniqueU8(const uint8 N, const int32 Data) return; } - FInsertUniqueU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueU8(ReducerArgs)); } + FInsertVecIdentityArgs ReducerArgs(I); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueU8(const FReducerEventContext& Context, const UInsertUniqueU8Reducer* Args) +bool URemoteReducers::InvokeInsertVecIdentity(const FReducerEventContext& Context, const UInsertVecIdentityReducer* Args) { - if (!OnInsertUniqueU8.IsBound()) + if (!OnInsertVecIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); } return false; } - OnInsertUniqueU8.Broadcast(Context, Args->N, Args->Data); + OnInsertVecIdentity.Broadcast(Context, Args->I); return true; } -bool URemoteReducers::InvokeInsertUniqueU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueU8Args& Args) +bool URemoteReducers::InvokeInsertVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertVecIdentityArgs& Args) { - if (!OnInsertUniqueU8.IsBound()) + if (!OnInsertVecIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); } return false; } - OnInsertUniqueU8.Broadcast(Context, Args.N, Args.Data); + OnInsertVecIdentity.Broadcast(Context, Args.I); return true; } -void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::InsertVecSimpleEnum(const TArray& E) { if (!Conn) { @@ -10750,45 +13946,45 @@ void URemoteReducers::InsertUniqueUuid(const FSpacetimeDBUuid& U, const int32 Da return; } - FInsertUniqueUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_unique_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUniqueUuid(ReducerArgs)); } + FInsertVecSimpleEnumArgs ReducerArgs(E); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUniqueUuid(const FReducerEventContext& Context, const UInsertUniqueUuidReducer* Args) +bool URemoteReducers::InvokeInsertVecSimpleEnum(const FReducerEventContext& Context, const UInsertVecSimpleEnumReducer* Args) { - if (!OnInsertUniqueUuid.IsBound()) + if (!OnInsertVecSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); } return false; } - OnInsertUniqueUuid.Broadcast(Context, Args->U, Args->Data); + OnInsertVecSimpleEnum.Broadcast(Context, Args->E); return true; } -bool URemoteReducers::InvokeInsertUniqueUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueUuidArgs& Args) +bool URemoteReducers::InvokeInsertVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertVecSimpleEnumArgs& Args) { - if (!OnInsertUniqueUuid.IsBound()) + if (!OnInsertVecSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUniqueUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); } return false; } - OnInsertUniqueUuid.Broadcast(Context, Args.U, Args.Data); + OnInsertVecSimpleEnum.Broadcast(Context, Args.E); return true; } -void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity& Identity) +void URemoteReducers::InsertVecString(const TArray& S) { if (!Conn) { @@ -10796,45 +13992,45 @@ void URemoteReducers::InsertUser(const FString& Name, const FSpacetimeDBIdentity return; } - FInsertUserArgs ReducerArgs(Name, Identity); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_user"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertUser(ReducerArgs)); } + FInsertVecStringArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertUser(const FReducerEventContext& Context, const UInsertUserReducer* Args) +bool URemoteReducers::InvokeInsertVecString(const FReducerEventContext& Context, const UInsertVecStringReducer* Args) { - if (!OnInsertUser.IsBound()) + if (!OnInsertVecString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); } return false; } - OnInsertUser.Broadcast(Context, Args->Name, Args->Identity); + OnInsertVecString.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertUserWithArgs(const FReducerEventContext& Context, const FInsertUserArgs& Args) +bool URemoteReducers::InvokeInsertVecStringWithArgs(const FReducerEventContext& Context, const FInsertVecStringArgs& Args) { - if (!OnInsertUser.IsBound()) + if (!OnInsertVecString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertUser")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); } return false; } - OnInsertUser.Broadcast(Context, Args.Name, Args.Identity); + OnInsertVecString.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertVecBool(const TArray& B) +void URemoteReducers::InsertVecTimestamp(const TArray& T) { if (!Conn) { @@ -10842,45 +14038,45 @@ void URemoteReducers::InsertVecBool(const TArray& B) return; } - FInsertVecBoolArgs ReducerArgs(B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecBool(ReducerArgs)); } + FInsertVecTimestampArgs ReducerArgs(T); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_timestamp"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecTimestamp(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecBool(const FReducerEventContext& Context, const UInsertVecBoolReducer* Args) +bool URemoteReducers::InvokeInsertVecTimestamp(const FReducerEventContext& Context, const UInsertVecTimestampReducer* Args) { - if (!OnInsertVecBool.IsBound()) + if (!OnInsertVecTimestamp.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); } return false; } - OnInsertVecBool.Broadcast(Context, Args->B); + OnInsertVecTimestamp.Broadcast(Context, Args->T); return true; } -bool URemoteReducers::InvokeInsertVecBoolWithArgs(const FReducerEventContext& Context, const FInsertVecBoolArgs& Args) +bool URemoteReducers::InvokeInsertVecTimestampWithArgs(const FReducerEventContext& Context, const FInsertVecTimestampArgs& Args) { - if (!OnInsertVecBool.IsBound()) + if (!OnInsertVecTimestamp.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); } return false; } - OnInsertVecBool.Broadcast(Context, Args.B); + OnInsertVecTimestamp.Broadcast(Context, Args.T); return true; } -void URemoteReducers::InsertVecByteStruct(const TArray& S) +void URemoteReducers::InsertVecU128(const TArray& N) { if (!Conn) { @@ -10888,45 +14084,45 @@ void URemoteReducers::InsertVecByteStruct(const TArray& S) return; } - FInsertVecByteStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_byte_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecByteStruct(ReducerArgs)); } + FInsertVecU128Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecByteStruct(const FReducerEventContext& Context, const UInsertVecByteStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU128(const FReducerEventContext& Context, const UInsertVecU128Reducer* Args) { - if (!OnInsertVecByteStruct.IsBound()) + if (!OnInsertVecU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); } return false; } - OnInsertVecByteStruct.Broadcast(Context, Args->S); + OnInsertVecU128.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecByteStructWithArgs(const FReducerEventContext& Context, const FInsertVecByteStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU128WithArgs(const FReducerEventContext& Context, const FInsertVecU128Args& Args) { - if (!OnInsertVecByteStruct.IsBound()) + if (!OnInsertVecU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecByteStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); } return false; } - OnInsertVecByteStruct.Broadcast(Context, Args.S); + OnInsertVecU128.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecConnectionId(const TArray& A) +void URemoteReducers::InsertVecU16(const TArray& N) { if (!Conn) { @@ -10934,45 +14130,45 @@ void URemoteReducers::InsertVecConnectionId(const TArrayCallReducerTyped(TEXT("insert_vec_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecConnectionId(ReducerArgs)); } + FInsertVecU16Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecConnectionId(const FReducerEventContext& Context, const UInsertVecConnectionIdReducer* Args) +bool URemoteReducers::InvokeInsertVecU16(const FReducerEventContext& Context, const UInsertVecU16Reducer* Args) { - if (!OnInsertVecConnectionId.IsBound()) + if (!OnInsertVecU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); } return false; } - OnInsertVecConnectionId.Broadcast(Context, Args->A); + OnInsertVecU16.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertVecConnectionIdArgs& Args) +bool URemoteReducers::InvokeInsertVecU16WithArgs(const FReducerEventContext& Context, const FInsertVecU16Args& Args) { - if (!OnInsertVecConnectionId.IsBound()) + if (!OnInsertVecU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); } return false; } - OnInsertVecConnectionId.Broadcast(Context, Args.A); + OnInsertVecU16.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEnumWithPayload(const TArray& E) +void URemoteReducers::InsertVecU256(const TArray& N) { if (!Conn) { @@ -10980,45 +14176,45 @@ void URemoteReducers::InsertVecEnumWithPayload(const TArrayCallReducerTyped(TEXT("insert_vec_enum_with_payload"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEnumWithPayload(ReducerArgs)); } + FInsertVecU256Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEnumWithPayload(const FReducerEventContext& Context, const UInsertVecEnumWithPayloadReducer* Args) +bool URemoteReducers::InvokeInsertVecU256(const FReducerEventContext& Context, const UInsertVecU256Reducer* Args) { - if (!OnInsertVecEnumWithPayload.IsBound()) + if (!OnInsertVecU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); } return false; } - OnInsertVecEnumWithPayload.Broadcast(Context, Args->E); + OnInsertVecU256.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEnumWithPayloadWithArgs(const FReducerEventContext& Context, const FInsertVecEnumWithPayloadArgs& Args) +bool URemoteReducers::InvokeInsertVecU256WithArgs(const FReducerEventContext& Context, const FInsertVecU256Args& Args) { - if (!OnInsertVecEnumWithPayload.IsBound()) + if (!OnInsertVecU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEnumWithPayload")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); } return false; } - OnInsertVecEnumWithPayload.Broadcast(Context, Args.E); + OnInsertVecU256.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArray& S) +void URemoteReducers::InsertVecU32(const TArray& N) { if (!Conn) { @@ -11026,45 +14222,45 @@ void URemoteReducers::InsertVecEveryPrimitiveStruct(const TArrayCallReducerTyped(TEXT("insert_vec_every_primitive_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryPrimitiveStruct(ReducerArgs)); } + FInsertVecU32Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEveryPrimitiveStruct(const FReducerEventContext& Context, const UInsertVecEveryPrimitiveStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU32(const FReducerEventContext& Context, const UInsertVecU32Reducer* Args) { - if (!OnInsertVecEveryPrimitiveStruct.IsBound()) + if (!OnInsertVecU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); } return false; } - OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args->S); + OnInsertVecU32.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEveryPrimitiveStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryPrimitiveStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU32WithArgs(const FReducerEventContext& Context, const FInsertVecU32Args& Args) { - if (!OnInsertVecEveryPrimitiveStruct.IsBound()) + if (!OnInsertVecU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryPrimitiveStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); } return false; } - OnInsertVecEveryPrimitiveStruct.Broadcast(Context, Args.S); + OnInsertVecU32.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecEveryVecStruct(const TArray& S) +void URemoteReducers::InsertVecU64(const TArray& N) { if (!Conn) { @@ -11072,45 +14268,45 @@ void URemoteReducers::InsertVecEveryVecStruct(const TArray& return; } - FInsertVecEveryVecStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_every_vec_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecEveryVecStruct(ReducerArgs)); } + FInsertVecU64Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecEveryVecStruct(const FReducerEventContext& Context, const UInsertVecEveryVecStructReducer* Args) +bool URemoteReducers::InvokeInsertVecU64(const FReducerEventContext& Context, const UInsertVecU64Reducer* Args) { - if (!OnInsertVecEveryVecStruct.IsBound()) + if (!OnInsertVecU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); } return false; } - OnInsertVecEveryVecStruct.Broadcast(Context, Args->S); + OnInsertVecU64.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecEveryVecStructWithArgs(const FReducerEventContext& Context, const FInsertVecEveryVecStructArgs& Args) +bool URemoteReducers::InvokeInsertVecU64WithArgs(const FReducerEventContext& Context, const FInsertVecU64Args& Args) { - if (!OnInsertVecEveryVecStruct.IsBound()) + if (!OnInsertVecU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecEveryVecStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); } return false; } - OnInsertVecEveryVecStruct.Broadcast(Context, Args.S); + OnInsertVecU64.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecF32(const TArray& F) +void URemoteReducers::InsertVecU8(const TArray& N) { if (!Conn) { @@ -11118,45 +14314,45 @@ void URemoteReducers::InsertVecF32(const TArray& F) return; } - FInsertVecF32Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF32(ReducerArgs)); } + FInsertVecU8Args ReducerArgs(N); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecF32(const FReducerEventContext& Context, const UInsertVecF32Reducer* Args) +bool URemoteReducers::InvokeInsertVecU8(const FReducerEventContext& Context, const UInsertVecU8Reducer* Args) { - if (!OnInsertVecF32.IsBound()) + if (!OnInsertVecU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); } return false; } - OnInsertVecF32.Broadcast(Context, Args->F); + OnInsertVecU8.Broadcast(Context, Args->N); return true; } -bool URemoteReducers::InvokeInsertVecF32WithArgs(const FReducerEventContext& Context, const FInsertVecF32Args& Args) +bool URemoteReducers::InvokeInsertVecU8WithArgs(const FReducerEventContext& Context, const FInsertVecU8Args& Args) { - if (!OnInsertVecF32.IsBound()) + if (!OnInsertVecU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); } return false; } - OnInsertVecF32.Broadcast(Context, Args.F); + OnInsertVecU8.Broadcast(Context, Args.N); return true; } -void URemoteReducers::InsertVecF64(const TArray& F) +void URemoteReducers::InsertVecUnitStruct(const TArray& S) { if (!Conn) { @@ -11164,45 +14360,45 @@ void URemoteReducers::InsertVecF64(const TArray& F) return; } - FInsertVecF64Args ReducerArgs(F); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_f_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecF64(ReducerArgs)); } + FInsertVecUnitStructArgs ReducerArgs(S); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_unit_struct"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUnitStruct(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecF64(const FReducerEventContext& Context, const UInsertVecF64Reducer* Args) +bool URemoteReducers::InvokeInsertVecUnitStruct(const FReducerEventContext& Context, const UInsertVecUnitStructReducer* Args) { - if (!OnInsertVecF64.IsBound()) + if (!OnInsertVecUnitStruct.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); } return false; } - OnInsertVecF64.Broadcast(Context, Args->F); + OnInsertVecUnitStruct.Broadcast(Context, Args->S); return true; } -bool URemoteReducers::InvokeInsertVecF64WithArgs(const FReducerEventContext& Context, const FInsertVecF64Args& Args) +bool URemoteReducers::InvokeInsertVecUnitStructWithArgs(const FReducerEventContext& Context, const FInsertVecUnitStructArgs& Args) { - if (!OnInsertVecF64.IsBound()) + if (!OnInsertVecUnitStruct.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecF64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); } return false; } - OnInsertVecF64.Broadcast(Context, Args.F); + OnInsertVecUnitStruct.Broadcast(Context, Args.S); return true; } -void URemoteReducers::InsertVecI128(const TArray& N) +void URemoteReducers::InsertVecUuid(const TArray& U) { if (!Conn) { @@ -11210,45 +14406,45 @@ void URemoteReducers::InsertVecI128(const TArray& N) return; } - FInsertVecI128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI128(ReducerArgs)); } + FInsertVecUuidArgs ReducerArgs(U); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI128(const FReducerEventContext& Context, const UInsertVecI128Reducer* Args) +bool URemoteReducers::InvokeInsertVecUuid(const FReducerEventContext& Context, const UInsertVecUuidReducer* Args) { - if (!OnInsertVecI128.IsBound()) + if (!OnInsertVecUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); } return false; } - OnInsertVecI128.Broadcast(Context, Args->N); + OnInsertVecUuid.Broadcast(Context, Args->U); return true; } -bool URemoteReducers::InvokeInsertVecI128WithArgs(const FReducerEventContext& Context, const FInsertVecI128Args& Args) +bool URemoteReducers::InvokeInsertVecUuidWithArgs(const FReducerEventContext& Context, const FInsertVecUuidArgs& Args) { - if (!OnInsertVecI128.IsBound()) + if (!OnInsertVecUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); } return false; } - OnInsertVecI128.Broadcast(Context, Args.N); + OnInsertVecUuid.Broadcast(Context, Args.U); return true; } -void URemoteReducers::InsertVecI16(const TArray& N) +void URemoteReducers::NoOpSucceeds() { if (!Conn) { @@ -11256,45 +14452,45 @@ void URemoteReducers::InsertVecI16(const TArray& N) return; } - FInsertVecI16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI16(ReducerArgs)); } + FNoOpSucceedsArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("no_op_succeeds"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::NoOpSucceeds(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI16(const FReducerEventContext& Context, const UInsertVecI16Reducer* Args) +bool URemoteReducers::InvokeNoOpSucceeds(const FReducerEventContext& Context, const UNoOpSucceedsReducer* Args) { - if (!OnInsertVecI16.IsBound()) + if (!OnNoOpSucceeds.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); } return false; } - OnInsertVecI16.Broadcast(Context, Args->N); + OnNoOpSucceeds.Broadcast(Context); return true; } -bool URemoteReducers::InvokeInsertVecI16WithArgs(const FReducerEventContext& Context, const FInsertVecI16Args& Args) +bool URemoteReducers::InvokeNoOpSucceedsWithArgs(const FReducerEventContext& Context, const FNoOpSucceedsArgs& Args) { - if (!OnInsertVecI16.IsBound()) + if (!OnNoOpSucceeds.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); } return false; } - OnInsertVecI16.Broadcast(Context, Args.N); + OnNoOpSucceeds.Broadcast(Context); return true; } -void URemoteReducers::InsertVecI256(const TArray& N) +void URemoteReducers::SortedUuidsInsert() { if (!Conn) { @@ -11302,45 +14498,45 @@ void URemoteReducers::InsertVecI256(const TArray& N) return; } - FInsertVecI256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI256(ReducerArgs)); } + FSortedUuidsInsertArgs ReducerArgs; + const uint32 RequestId = Conn->CallReducerTyped(TEXT("sorted_uuids_insert"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::SortedUuidsInsert(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI256(const FReducerEventContext& Context, const UInsertVecI256Reducer* Args) +bool URemoteReducers::InvokeSortedUuidsInsert(const FReducerEventContext& Context, const USortedUuidsInsertReducer* Args) { - if (!OnInsertVecI256.IsBound()) + if (!OnSortedUuidsInsert.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); } return false; } - OnInsertVecI256.Broadcast(Context, Args->N); + OnSortedUuidsInsert.Broadcast(Context); return true; } -bool URemoteReducers::InvokeInsertVecI256WithArgs(const FReducerEventContext& Context, const FInsertVecI256Args& Args) +bool URemoteReducers::InvokeSortedUuidsInsertWithArgs(const FReducerEventContext& Context, const FSortedUuidsInsertArgs& Args) { - if (!OnInsertVecI256.IsBound()) + if (!OnSortedUuidsInsert.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); } return false; } - OnInsertVecI256.Broadcast(Context, Args.N); + OnSortedUuidsInsert.Broadcast(Context); return true; } -void URemoteReducers::InsertVecI32(const TArray& N) +void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ESimpleEnumType& B) { if (!Conn) { @@ -11348,45 +14544,45 @@ void URemoteReducers::InsertVecI32(const TArray& N) return; } - FInsertVecI32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI32(ReducerArgs)); } + FUpdateIndexedSimpleEnumArgs ReducerArgs(A, B); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_indexed_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateIndexedSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI32(const FReducerEventContext& Context, const UInsertVecI32Reducer* Args) +bool URemoteReducers::InvokeUpdateIndexedSimpleEnum(const FReducerEventContext& Context, const UUpdateIndexedSimpleEnumReducer* Args) { - if (!OnInsertVecI32.IsBound()) + if (!OnUpdateIndexedSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); } return false; } - OnInsertVecI32.Broadcast(Context, Args->N); + OnUpdateIndexedSimpleEnum.Broadcast(Context, Args->A, Args->B); return true; } -bool URemoteReducers::InvokeInsertVecI32WithArgs(const FReducerEventContext& Context, const FInsertVecI32Args& Args) +bool URemoteReducers::InvokeUpdateIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdateIndexedSimpleEnumArgs& Args) { - if (!OnInsertVecI32.IsBound()) + if (!OnUpdateIndexedSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); } return false; } - OnInsertVecI32.Broadcast(Context, Args.N); + OnUpdateIndexedSimpleEnum.Broadcast(Context, Args.A, Args.B); return true; } -void URemoteReducers::InsertVecI64(const TArray& N) +void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) { if (!Conn) { @@ -11394,45 +14590,45 @@ void URemoteReducers::InsertVecI64(const TArray& N) return; } - FInsertVecI64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI64(ReducerArgs)); } + FUpdatePkBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkBool(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI64(const FReducerEventContext& Context, const UInsertVecI64Reducer* Args) +bool URemoteReducers::InvokeUpdatePkBool(const FReducerEventContext& Context, const UUpdatePkBoolReducer* Args) { - if (!OnInsertVecI64.IsBound()) + if (!OnUpdatePkBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); } return false; } - OnInsertVecI64.Broadcast(Context, Args->N); + OnUpdatePkBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecI64WithArgs(const FReducerEventContext& Context, const FInsertVecI64Args& Args) +bool URemoteReducers::InvokeUpdatePkBoolWithArgs(const FReducerEventContext& Context, const FUpdatePkBoolArgs& Args) { - if (!OnInsertVecI64.IsBound()) + if (!OnUpdatePkBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); } return false; } - OnInsertVecI64.Broadcast(Context, Args.N); + OnUpdatePkBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::InsertVecI8(const TArray& N) +void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -11440,45 +14636,45 @@ void URemoteReducers::InsertVecI8(const TArray& N) return; } - FInsertVecI8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecI8(ReducerArgs)); } + FUpdatePkConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecI8(const FReducerEventContext& Context, const UInsertVecI8Reducer* Args) +bool URemoteReducers::InvokeUpdatePkConnectionId(const FReducerEventContext& Context, const UUpdatePkConnectionIdReducer* Args) { - if (!OnInsertVecI8.IsBound()) + if (!OnUpdatePkConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); } return false; } - OnInsertVecI8.Broadcast(Context, Args->N); + OnUpdatePkConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecI8WithArgs(const FReducerEventContext& Context, const FInsertVecI8Args& Args) +bool URemoteReducers::InvokeUpdatePkConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdatePkConnectionIdArgs& Args) { - if (!OnInsertVecI8.IsBound()) + if (!OnUpdatePkConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); } return false; } - OnInsertVecI8.Broadcast(Context, Args.N); + OnUpdatePkConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertVecIdentity(const TArray& I) +void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -11486,45 +14682,45 @@ void URemoteReducers::InsertVecIdentity(const TArray& I) return; } - FInsertVecIdentityArgs ReducerArgs(I); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecIdentity(ReducerArgs)); } + FUpdatePkI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecIdentity(const FReducerEventContext& Context, const UInsertVecIdentityReducer* Args) +bool URemoteReducers::InvokeUpdatePkI128(const FReducerEventContext& Context, const UUpdatePkI128Reducer* Args) { - if (!OnInsertVecIdentity.IsBound()) + if (!OnUpdatePkI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); } return false; } - OnInsertVecIdentity.Broadcast(Context, Args->I); + OnUpdatePkI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecIdentityWithArgs(const FReducerEventContext& Context, const FInsertVecIdentityArgs& Args) +bool URemoteReducers::InvokeUpdatePkI128WithArgs(const FReducerEventContext& Context, const FUpdatePkI128Args& Args) { - if (!OnInsertVecIdentity.IsBound()) + if (!OnUpdatePkI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); } return false; } - OnInsertVecIdentity.Broadcast(Context, Args.I); + OnUpdatePkI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecSimpleEnum(const TArray& E) +void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) { if (!Conn) { @@ -11532,45 +14728,45 @@ void URemoteReducers::InsertVecSimpleEnum(const TArray& E) return; } - FInsertVecSimpleEnumArgs ReducerArgs(E); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecSimpleEnum(ReducerArgs)); } + FUpdatePkI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecSimpleEnum(const FReducerEventContext& Context, const UInsertVecSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdatePkI16(const FReducerEventContext& Context, const UUpdatePkI16Reducer* Args) { - if (!OnInsertVecSimpleEnum.IsBound()) + if (!OnUpdatePkI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); } return false; } - OnInsertVecSimpleEnum.Broadcast(Context, Args->E); + OnUpdatePkI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecSimpleEnumWithArgs(const FReducerEventContext& Context, const FInsertVecSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdatePkI16WithArgs(const FReducerEventContext& Context, const FUpdatePkI16Args& Args) { - if (!OnInsertVecSimpleEnum.IsBound()) + if (!OnUpdatePkI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); } return false; } - OnInsertVecSimpleEnum.Broadcast(Context, Args.E); + OnUpdatePkI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecString(const TArray& S) +void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -11578,45 +14774,45 @@ void URemoteReducers::InsertVecString(const TArray& S) return; } - FInsertVecStringArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecString(ReducerArgs)); } + FUpdatePkI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecString(const FReducerEventContext& Context, const UInsertVecStringReducer* Args) +bool URemoteReducers::InvokeUpdatePkI256(const FReducerEventContext& Context, const UUpdatePkI256Reducer* Args) { - if (!OnInsertVecString.IsBound()) + if (!OnUpdatePkI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); } return false; } - OnInsertVecString.Broadcast(Context, Args->S); + OnUpdatePkI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecStringWithArgs(const FReducerEventContext& Context, const FInsertVecStringArgs& Args) +bool URemoteReducers::InvokeUpdatePkI256WithArgs(const FReducerEventContext& Context, const FUpdatePkI256Args& Args) { - if (!OnInsertVecString.IsBound()) + if (!OnUpdatePkI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); } return false; } - OnInsertVecString.Broadcast(Context, Args.S); + OnUpdatePkI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecTimestamp(const TArray& T) +void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) { if (!Conn) { @@ -11624,45 +14820,45 @@ void URemoteReducers::InsertVecTimestamp(const TArray& T) return; } - FInsertVecTimestampArgs ReducerArgs(T); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_timestamp"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecTimestamp(ReducerArgs)); } + FUpdatePkI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI32(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecTimestamp(const FReducerEventContext& Context, const UInsertVecTimestampReducer* Args) +bool URemoteReducers::InvokeUpdatePkI32(const FReducerEventContext& Context, const UUpdatePkI32Reducer* Args) { - if (!OnInsertVecTimestamp.IsBound()) + if (!OnUpdatePkI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); } return false; } - OnInsertVecTimestamp.Broadcast(Context, Args->T); + OnUpdatePkI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecTimestampWithArgs(const FReducerEventContext& Context, const FInsertVecTimestampArgs& Args) +bool URemoteReducers::InvokeUpdatePkI32WithArgs(const FReducerEventContext& Context, const FUpdatePkI32Args& Args) { - if (!OnInsertVecTimestamp.IsBound()) + if (!OnUpdatePkI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecTimestamp")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); } return false; } - OnInsertVecTimestamp.Broadcast(Context, Args.T); + OnUpdatePkI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU128(const TArray& N) +void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) { if (!Conn) { @@ -11670,45 +14866,45 @@ void URemoteReducers::InsertVecU128(const TArray& N) return; } - FInsertVecU128Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU128(ReducerArgs)); } + FUpdatePkI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI64(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU128(const FReducerEventContext& Context, const UInsertVecU128Reducer* Args) +bool URemoteReducers::InvokeUpdatePkI64(const FReducerEventContext& Context, const UUpdatePkI64Reducer* Args) { - if (!OnInsertVecU128.IsBound()) + if (!OnUpdatePkI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); } return false; } - OnInsertVecU128.Broadcast(Context, Args->N); + OnUpdatePkI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU128WithArgs(const FReducerEventContext& Context, const FInsertVecU128Args& Args) +bool URemoteReducers::InvokeUpdatePkI64WithArgs(const FReducerEventContext& Context, const FUpdatePkI64Args& Args) { - if (!OnInsertVecU128.IsBound()) + if (!OnUpdatePkI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); } return false; } - OnInsertVecU128.Broadcast(Context, Args.N); + OnUpdatePkI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU16(const TArray& N) +void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) { if (!Conn) { @@ -11716,45 +14912,45 @@ void URemoteReducers::InsertVecU16(const TArray& N) return; } - FInsertVecU16Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU16(ReducerArgs)); } + FUpdatePkI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI8(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU16(const FReducerEventContext& Context, const UInsertVecU16Reducer* Args) +bool URemoteReducers::InvokeUpdatePkI8(const FReducerEventContext& Context, const UUpdatePkI8Reducer* Args) { - if (!OnInsertVecU16.IsBound()) + if (!OnUpdatePkI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); } return false; } - OnInsertVecU16.Broadcast(Context, Args->N); + OnUpdatePkI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU16WithArgs(const FReducerEventContext& Context, const FInsertVecU16Args& Args) +bool URemoteReducers::InvokeUpdatePkI8WithArgs(const FReducerEventContext& Context, const FUpdatePkI8Args& Args) { - if (!OnInsertVecU16.IsBound()) + if (!OnUpdatePkI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); } return false; } - OnInsertVecU16.Broadcast(Context, Args.N); + OnUpdatePkI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecU256(const TArray& N) +void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -11762,45 +14958,45 @@ void URemoteReducers::InsertVecU256(const TArray& N) return; } - FInsertVecU256Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU256(ReducerArgs)); } + FUpdatePkIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU256(const FReducerEventContext& Context, const UInsertVecU256Reducer* Args) +bool URemoteReducers::InvokeUpdatePkIdentity(const FReducerEventContext& Context, const UUpdatePkIdentityReducer* Args) { - if (!OnInsertVecU256.IsBound()) + if (!OnUpdatePkIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); } return false; } - OnInsertVecU256.Broadcast(Context, Args->N); + OnUpdatePkIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU256WithArgs(const FReducerEventContext& Context, const FInsertVecU256Args& Args) +bool URemoteReducers::InvokeUpdatePkIdentityWithArgs(const FReducerEventContext& Context, const FUpdatePkIdentityArgs& Args) { - if (!OnInsertVecU256.IsBound()) + if (!OnUpdatePkIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); } return false; } - OnInsertVecU256.Broadcast(Context, Args.N); + OnUpdatePkIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::InsertVecU32(const TArray& N) +void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 Data) { if (!Conn) { @@ -11808,45 +15004,45 @@ void URemoteReducers::InsertVecU32(const TArray& N) return; } - FInsertVecU32Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU32(ReducerArgs)); } + FUpdatePkSimpleEnumArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_simple_enum"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkSimpleEnum(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU32(const FReducerEventContext& Context, const UInsertVecU32Reducer* Args) +bool URemoteReducers::InvokeUpdatePkSimpleEnum(const FReducerEventContext& Context, const UUpdatePkSimpleEnumReducer* Args) { - if (!OnInsertVecU32.IsBound()) + if (!OnUpdatePkSimpleEnum.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); } return false; } - OnInsertVecU32.Broadcast(Context, Args->N); + OnUpdatePkSimpleEnum.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU32WithArgs(const FReducerEventContext& Context, const FInsertVecU32Args& Args) +bool URemoteReducers::InvokeUpdatePkSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdatePkSimpleEnumArgs& Args) { - if (!OnInsertVecU32.IsBound()) + if (!OnUpdatePkSimpleEnum.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); } return false; } - OnInsertVecU32.Broadcast(Context, Args.N); + OnUpdatePkSimpleEnum.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::InsertVecU64(const TArray& N) +void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) { if (!Conn) { @@ -11854,45 +15050,45 @@ void URemoteReducers::InsertVecU64(const TArray& N) return; } - FInsertVecU64Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU64(ReducerArgs)); } + FUpdatePkStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkString(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU64(const FReducerEventContext& Context, const UInsertVecU64Reducer* Args) +bool URemoteReducers::InvokeUpdatePkString(const FReducerEventContext& Context, const UUpdatePkStringReducer* Args) { - if (!OnInsertVecU64.IsBound()) + if (!OnUpdatePkString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); } return false; } - OnInsertVecU64.Broadcast(Context, Args->N); + OnUpdatePkString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU64WithArgs(const FReducerEventContext& Context, const FInsertVecU64Args& Args) +bool URemoteReducers::InvokeUpdatePkStringWithArgs(const FReducerEventContext& Context, const FUpdatePkStringArgs& Args) { - if (!OnInsertVecU64.IsBound()) + if (!OnUpdatePkString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); } return false; } - OnInsertVecU64.Broadcast(Context, Args.N); + OnUpdatePkString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::InsertVecU8(const TArray& N) +void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Data) { if (!Conn) { @@ -11900,45 +15096,45 @@ void URemoteReducers::InsertVecU8(const TArray& N) return; } - FInsertVecU8Args ReducerArgs(N); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecU8(ReducerArgs)); } + FUpdatePkU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU128(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecU8(const FReducerEventContext& Context, const UInsertVecU8Reducer* Args) +bool URemoteReducers::InvokeUpdatePkU128(const FReducerEventContext& Context, const UUpdatePkU128Reducer* Args) { - if (!OnInsertVecU8.IsBound()) + if (!OnUpdatePkU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); } return false; } - OnInsertVecU8.Broadcast(Context, Args->N); + OnUpdatePkU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecU8WithArgs(const FReducerEventContext& Context, const FInsertVecU8Args& Args) +bool URemoteReducers::InvokeUpdatePkU128WithArgs(const FReducerEventContext& Context, const FUpdatePkU128Args& Args) { - if (!OnInsertVecU8.IsBound()) + if (!OnUpdatePkU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); } return false; } - OnInsertVecU8.Broadcast(Context, Args.N); + OnUpdatePkU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecUnitStruct(const TArray& S) +void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) { if (!Conn) { @@ -11946,45 +15142,45 @@ void URemoteReducers::InsertVecUnitStruct(const TArray& S) return; } - FInsertVecUnitStructArgs ReducerArgs(S); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_unit_struct"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUnitStruct(ReducerArgs)); } + FUpdatePkU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU16(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecUnitStruct(const FReducerEventContext& Context, const UInsertVecUnitStructReducer* Args) +bool URemoteReducers::InvokeUpdatePkU16(const FReducerEventContext& Context, const UUpdatePkU16Reducer* Args) { - if (!OnInsertVecUnitStruct.IsBound()) + if (!OnUpdatePkU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); } return false; } - OnInsertVecUnitStruct.Broadcast(Context, Args->S); + OnUpdatePkU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecUnitStructWithArgs(const FReducerEventContext& Context, const FInsertVecUnitStructArgs& Args) +bool URemoteReducers::InvokeUpdatePkU16WithArgs(const FReducerEventContext& Context, const FUpdatePkU16Args& Args) { - if (!OnInsertVecUnitStruct.IsBound()) + if (!OnUpdatePkU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUnitStruct")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); } return false; } - OnInsertVecUnitStruct.Broadcast(Context, Args.S); + OnUpdatePkU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::InsertVecUuid(const TArray& U) +void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Data) { if (!Conn) { @@ -11992,45 +15188,45 @@ void URemoteReducers::InsertVecUuid(const TArray& U) return; } - FInsertVecUuidArgs ReducerArgs(U); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("insert_vec_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::InsertVecUuid(ReducerArgs)); } + FUpdatePkU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU256(ReducerArgs)); } } -bool URemoteReducers::InvokeInsertVecUuid(const FReducerEventContext& Context, const UInsertVecUuidReducer* Args) +bool URemoteReducers::InvokeUpdatePkU256(const FReducerEventContext& Context, const UUpdatePkU256Reducer* Args) { - if (!OnInsertVecUuid.IsBound()) + if (!OnUpdatePkU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); } return false; } - OnInsertVecUuid.Broadcast(Context, Args->U); + OnUpdatePkU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeInsertVecUuidWithArgs(const FReducerEventContext& Context, const FInsertVecUuidArgs& Args) +bool URemoteReducers::InvokeUpdatePkU256WithArgs(const FReducerEventContext& Context, const FUpdatePkU256Args& Args) { - if (!OnInsertVecUuid.IsBound()) + if (!OnUpdatePkU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for InsertVecUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); } return false; } - OnInsertVecUuid.Broadcast(Context, Args.U); + OnUpdatePkU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::NoOpSucceeds() +void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) { if (!Conn) { @@ -12038,45 +15234,45 @@ void URemoteReducers::NoOpSucceeds() return; } - FNoOpSucceedsArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("no_op_succeeds"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::NoOpSucceeds(ReducerArgs)); } + FUpdatePkU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32(ReducerArgs)); } } -bool URemoteReducers::InvokeNoOpSucceeds(const FReducerEventContext& Context, const UNoOpSucceedsReducer* Args) +bool URemoteReducers::InvokeUpdatePkU32(const FReducerEventContext& Context, const UUpdatePkU32Reducer* Args) { - if (!OnNoOpSucceeds.IsBound()) + if (!OnUpdatePkU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); } return false; } - OnNoOpSucceeds.Broadcast(Context); + OnUpdatePkU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeNoOpSucceedsWithArgs(const FReducerEventContext& Context, const FNoOpSucceedsArgs& Args) +bool URemoteReducers::InvokeUpdatePkU32WithArgs(const FReducerEventContext& Context, const FUpdatePkU32Args& Args) { - if (!OnNoOpSucceeds.IsBound()) + if (!OnUpdatePkU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for NoOpSucceeds")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); } return false; } - OnNoOpSucceeds.Broadcast(Context); + OnUpdatePkU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::SortedUuidsInsert() +void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) { if (!Conn) { @@ -12084,45 +15280,45 @@ void URemoteReducers::SortedUuidsInsert() return; } - FSortedUuidsInsertArgs ReducerArgs; - const uint32 RequestId = Conn->CallReducerTyped(TEXT("sorted_uuids_insert"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::SortedUuidsInsert(ReducerArgs)); } + FUpdatePkU32TwoArgs ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32_two"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32Two(ReducerArgs)); } } -bool URemoteReducers::InvokeSortedUuidsInsert(const FReducerEventContext& Context, const USortedUuidsInsertReducer* Args) +bool URemoteReducers::InvokeUpdatePkU32Two(const FReducerEventContext& Context, const UUpdatePkU32TwoReducer* Args) { - if (!OnSortedUuidsInsert.IsBound()) + if (!OnUpdatePkU32Two.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); } return false; } - OnSortedUuidsInsert.Broadcast(Context); + OnUpdatePkU32Two.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeSortedUuidsInsertWithArgs(const FReducerEventContext& Context, const FSortedUuidsInsertArgs& Args) +bool URemoteReducers::InvokeUpdatePkU32TwoWithArgs(const FReducerEventContext& Context, const FUpdatePkU32TwoArgs& Args) { - if (!OnSortedUuidsInsert.IsBound()) + if (!OnUpdatePkU32Two.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for SortedUuidsInsert")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); } return false; } - OnSortedUuidsInsert.Broadcast(Context); + OnUpdatePkU32Two.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ESimpleEnumType& B) +void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) { if (!Conn) { @@ -12130,45 +15326,45 @@ void URemoteReducers::UpdateIndexedSimpleEnum(const ESimpleEnumType& A, const ES return; } - FUpdateIndexedSimpleEnumArgs ReducerArgs(A, B); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_indexed_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateIndexedSimpleEnum(ReducerArgs)); } + FUpdatePkU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateIndexedSimpleEnum(const FReducerEventContext& Context, const UUpdateIndexedSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdatePkU64(const FReducerEventContext& Context, const UUpdatePkU64Reducer* Args) { - if (!OnUpdateIndexedSimpleEnum.IsBound()) + if (!OnUpdatePkU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); } return false; } - OnUpdateIndexedSimpleEnum.Broadcast(Context, Args->A, Args->B); + OnUpdatePkU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateIndexedSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdateIndexedSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdatePkU64WithArgs(const FReducerEventContext& Context, const FUpdatePkU64Args& Args) { - if (!OnUpdateIndexedSimpleEnum.IsBound()) + if (!OnUpdatePkU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateIndexedSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); } return false; } - OnUpdateIndexedSimpleEnum.Broadcast(Context, Args.A, Args.B); + OnUpdatePkU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) +void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) { if (!Conn) { @@ -12176,45 +15372,45 @@ void URemoteReducers::UpdatePkBool(const bool B, const int32 Data) return; } - FUpdatePkBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkBool(ReducerArgs)); } + FUpdatePkU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkBool(const FReducerEventContext& Context, const UUpdatePkBoolReducer* Args) +bool URemoteReducers::InvokeUpdatePkU8(const FReducerEventContext& Context, const UUpdatePkU8Reducer* Args) { - if (!OnUpdatePkBool.IsBound()) + if (!OnUpdatePkU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); } return false; } - OnUpdatePkBool.Broadcast(Context, Args->B, Args->Data); + OnUpdatePkU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkBoolWithArgs(const FReducerEventContext& Context, const FUpdatePkBoolArgs& Args) +bool URemoteReducers::InvokeUpdatePkU8WithArgs(const FReducerEventContext& Context, const FUpdatePkU8Args& Args) { - if (!OnUpdatePkBool.IsBound()) + if (!OnUpdatePkU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); } return false; } - OnUpdatePkBool.Broadcast(Context, Args.B, Args.Data); + OnUpdatePkU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) { if (!Conn) { @@ -12222,45 +15418,45 @@ void URemoteReducers::UpdatePkConnectionId(const FSpacetimeDBConnectionId& A, co return; } - FUpdatePkConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkConnectionId(ReducerArgs)); } + FUpdatePkUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkConnectionId(const FReducerEventContext& Context, const UUpdatePkConnectionIdReducer* Args) +bool URemoteReducers::InvokeUpdatePkUuid(const FReducerEventContext& Context, const UUpdatePkUuidReducer* Args) { - if (!OnUpdatePkConnectionId.IsBound()) + if (!OnUpdatePkUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); } return false; } - OnUpdatePkConnectionId.Broadcast(Context, Args->A, Args->Data); + OnUpdatePkUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdatePkConnectionIdArgs& Args) +bool URemoteReducers::InvokeUpdatePkUuidWithArgs(const FReducerEventContext& Context, const FUpdatePkUuidArgs& Args) { - if (!OnUpdatePkConnectionId.IsBound()) + if (!OnUpdatePkUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); } return false; } - OnUpdatePkConnectionId.Broadcast(Context, Args.A, Args.Data); + OnUpdatePkUuid.Broadcast(Context, Args.U, Args.Data); return true; } -void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) { if (!Conn) { @@ -12268,45 +15464,45 @@ void URemoteReducers::UpdatePkI128(const FSpacetimeDBInt128& N, const int32 Data return; } - FUpdatePkI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI128(ReducerArgs)); } + FUpdateUniqueBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueBool(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI128(const FReducerEventContext& Context, const UUpdatePkI128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueBool(const FReducerEventContext& Context, const UUpdateUniqueBoolReducer* Args) { - if (!OnUpdatePkI128.IsBound()) + if (!OnUpdateUniqueBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); } return false; } - OnUpdatePkI128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI128WithArgs(const FReducerEventContext& Context, const FUpdatePkI128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueBoolArgs& Args) { - if (!OnUpdatePkI128.IsBound()) + if (!OnUpdateUniqueBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); } return false; } - OnUpdatePkI128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) +void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) { if (!Conn) { @@ -12314,45 +15510,45 @@ void URemoteReducers::UpdatePkI16(const int16 N, const int32 Data) return; } - FUpdatePkI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI16(ReducerArgs)); } + FUpdateUniqueConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI16(const FReducerEventContext& Context, const UUpdatePkI16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueConnectionId(const FReducerEventContext& Context, const UUpdateUniqueConnectionIdReducer* Args) { - if (!OnUpdatePkI16.IsBound()) + if (!OnUpdateUniqueConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); } return false; } - OnUpdatePkI16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI16WithArgs(const FReducerEventContext& Context, const FUpdatePkI16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueConnectionIdArgs& Args) { - if (!OnUpdatePkI16.IsBound()) + if (!OnUpdateUniqueConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); } return false; } - OnUpdatePkI16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) { if (!Conn) { @@ -12360,45 +15556,45 @@ void URemoteReducers::UpdatePkI256(const FSpacetimeDBInt256& N, const int32 Data return; } - FUpdatePkI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI256(ReducerArgs)); } + FUpdateUniqueI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI256(const FReducerEventContext& Context, const UUpdatePkI256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI128(const FReducerEventContext& Context, const UUpdateUniqueI128Reducer* Args) { - if (!OnUpdatePkI256.IsBound()) + if (!OnUpdateUniqueI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); } return false; } - OnUpdatePkI256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI256WithArgs(const FReducerEventContext& Context, const FUpdatePkI256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI128Args& Args) { - if (!OnUpdatePkI256.IsBound()) + if (!OnUpdateUniqueI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); } return false; } - OnUpdatePkI256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) +void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) { if (!Conn) { @@ -12406,45 +15602,45 @@ void URemoteReducers::UpdatePkI32(const int32 N, const int32 Data) return; } - FUpdatePkI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI32(ReducerArgs)); } + FUpdateUniqueI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI32(const FReducerEventContext& Context, const UUpdatePkI32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI16(const FReducerEventContext& Context, const UUpdateUniqueI16Reducer* Args) { - if (!OnUpdatePkI32.IsBound()) + if (!OnUpdateUniqueI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); } return false; } - OnUpdatePkI32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI32WithArgs(const FReducerEventContext& Context, const FUpdatePkI32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI16Args& Args) { - if (!OnUpdatePkI32.IsBound()) + if (!OnUpdateUniqueI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); } return false; } - OnUpdatePkI32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) +void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) { if (!Conn) { @@ -12452,45 +15648,45 @@ void URemoteReducers::UpdatePkI64(const int64 N, const int32 Data) return; } - FUpdatePkI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI64(ReducerArgs)); } + FUpdateUniqueI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI64(const FReducerEventContext& Context, const UUpdatePkI64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI256(const FReducerEventContext& Context, const UUpdateUniqueI256Reducer* Args) { - if (!OnUpdatePkI64.IsBound()) + if (!OnUpdateUniqueI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); } return false; } - OnUpdatePkI64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI64WithArgs(const FReducerEventContext& Context, const FUpdatePkI64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI256Args& Args) { - if (!OnUpdatePkI64.IsBound()) + if (!OnUpdateUniqueI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); } return false; } - OnUpdatePkI64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) +void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) { if (!Conn) { @@ -12498,45 +15694,45 @@ void URemoteReducers::UpdatePkI8(const int8 N, const int32 Data) return; } - FUpdatePkI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkI8(ReducerArgs)); } + FUpdateUniqueI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkI8(const FReducerEventContext& Context, const UUpdatePkI8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI32(const FReducerEventContext& Context, const UUpdateUniqueI32Reducer* Args) { - if (!OnUpdatePkI8.IsBound()) + if (!OnUpdateUniqueI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); } return false; } - OnUpdatePkI8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkI8WithArgs(const FReducerEventContext& Context, const FUpdatePkI8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI32Args& Args) { - if (!OnUpdatePkI8.IsBound()) + if (!OnUpdateUniqueI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); } return false; } - OnUpdatePkI8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) { if (!Conn) { @@ -12544,45 +15740,45 @@ void URemoteReducers::UpdatePkIdentity(const FSpacetimeDBIdentity& I, const int3 return; } - FUpdatePkIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkIdentity(ReducerArgs)); } + FUpdateUniqueI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkIdentity(const FReducerEventContext& Context, const UUpdatePkIdentityReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI64(const FReducerEventContext& Context, const UUpdateUniqueI64Reducer* Args) { - if (!OnUpdatePkIdentity.IsBound()) + if (!OnUpdateUniqueI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); } return false; } - OnUpdatePkIdentity.Broadcast(Context, Args->I, Args->Data); + OnUpdateUniqueI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkIdentityWithArgs(const FReducerEventContext& Context, const FUpdatePkIdentityArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI64Args& Args) { - if (!OnUpdatePkIdentity.IsBound()) + if (!OnUpdateUniqueI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); } return false; } - OnUpdatePkIdentity.Broadcast(Context, Args.I, Args.Data); + OnUpdateUniqueI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 Data) +void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) { if (!Conn) { @@ -12590,45 +15786,45 @@ void URemoteReducers::UpdatePkSimpleEnum(const ESimpleEnumType& A, const int32 D return; } - FUpdatePkSimpleEnumArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_simple_enum"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkSimpleEnum(ReducerArgs)); } + FUpdateUniqueI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkSimpleEnum(const FReducerEventContext& Context, const UUpdatePkSimpleEnumReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueI8(const FReducerEventContext& Context, const UUpdateUniqueI8Reducer* Args) { - if (!OnUpdatePkSimpleEnum.IsBound()) + if (!OnUpdateUniqueI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); } return false; } - OnUpdatePkSimpleEnum.Broadcast(Context, Args->A, Args->Data); + OnUpdateUniqueI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkSimpleEnumWithArgs(const FReducerEventContext& Context, const FUpdatePkSimpleEnumArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI8Args& Args) { - if (!OnUpdatePkSimpleEnum.IsBound()) + if (!OnUpdateUniqueI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkSimpleEnum")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); } return false; } - OnUpdatePkSimpleEnum.Broadcast(Context, Args.A, Args.Data); + OnUpdateUniqueI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) +void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) { if (!Conn) { @@ -12636,45 +15832,45 @@ void URemoteReducers::UpdatePkString(const FString& S, const int32 Data) return; } - FUpdatePkStringArgs ReducerArgs(S, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_string"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkString(ReducerArgs)); } + FUpdateUniqueIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkString(const FReducerEventContext& Context, const UUpdatePkStringReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueIdentity(const FReducerEventContext& Context, const UUpdateUniqueIdentityReducer* Args) { - if (!OnUpdatePkString.IsBound()) + if (!OnUpdateUniqueIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); } return false; } - OnUpdatePkString.Broadcast(Context, Args->S, Args->Data); + OnUpdateUniqueIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkStringWithArgs(const FReducerEventContext& Context, const FUpdatePkStringArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args) { - if (!OnUpdatePkString.IsBound()) + if (!OnUpdateUniqueIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkString")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); } return false; } - OnUpdatePkString.Broadcast(Context, Args.S, Args.Data); + OnUpdateUniqueIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data) { if (!Conn) { @@ -12682,45 +15878,45 @@ void URemoteReducers::UpdatePkU128(const FSpacetimeDBUInt128& N, const int32 Dat return; } - FUpdatePkU128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU128(ReducerArgs)); } + FUpdateUniqueOptionBoolArgs ReducerArgs(B, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_bool"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionBool(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU128(const FReducerEventContext& Context, const UUpdatePkU128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionBool(const FReducerEventContext& Context, const UUpdateUniqueOptionBoolReducer* Args) { - if (!OnUpdatePkU128.IsBound()) + if (!OnUpdateUniqueOptionBool.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionBool")); } return false; } - OnUpdatePkU128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionBool.Broadcast(Context, Args->B, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU128WithArgs(const FReducerEventContext& Context, const FUpdatePkU128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionBoolArgs& Args) { - if (!OnUpdatePkU128.IsBound()) + if (!OnUpdateUniqueOptionBool.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionBool")); } return false; } - OnUpdatePkU128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionBool.Broadcast(Context, Args.B, Args.Data); return true; } -void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data) { if (!Conn) { @@ -12728,45 +15924,45 @@ void URemoteReducers::UpdatePkU16(const uint16 N, const int32 Data) return; } - FUpdatePkU16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU16(ReducerArgs)); } + FUpdateUniqueOptionConnectionIdArgs ReducerArgs(A, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_connection_id"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionConnectionId(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU16(const FReducerEventContext& Context, const UUpdatePkU16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionConnectionId(const FReducerEventContext& Context, const UUpdateUniqueOptionConnectionIdReducer* Args) { - if (!OnUpdatePkU16.IsBound()) + if (!OnUpdateUniqueOptionConnectionId.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionConnectionId")); } return false; } - OnUpdatePkU16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionConnectionId.Broadcast(Context, Args->A, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU16WithArgs(const FReducerEventContext& Context, const FUpdatePkU16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionConnectionIdArgs& Args) { - if (!OnUpdatePkU16.IsBound()) + if (!OnUpdateUniqueOptionConnectionId.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionConnectionId")); } return false; } - OnUpdatePkU16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionConnectionId.Broadcast(Context, Args.A, Args.Data); return true; } -void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data) { if (!Conn) { @@ -12774,45 +15970,45 @@ void URemoteReducers::UpdatePkU256(const FSpacetimeDBUInt256& N, const int32 Dat return; } - FUpdatePkU256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU256(ReducerArgs)); } + FUpdateUniqueOptionI128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU256(const FReducerEventContext& Context, const UUpdatePkU256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI128(const FReducerEventContext& Context, const UUpdateUniqueOptionI128Reducer* Args) { - if (!OnUpdatePkU256.IsBound()) + if (!OnUpdateUniqueOptionI128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI128")); } return false; } - OnUpdatePkU256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU256WithArgs(const FReducerEventContext& Context, const FUpdatePkU256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI128Args& Args) { - if (!OnUpdatePkU256.IsBound()) + if (!OnUpdateUniqueOptionI128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI128")); } return false; } - OnUpdatePkU256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data) { if (!Conn) { @@ -12820,45 +16016,45 @@ void URemoteReducers::UpdatePkU32(const uint32 N, const int32 Data) return; } - FUpdatePkU32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32(ReducerArgs)); } + FUpdateUniqueOptionI16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU32(const FReducerEventContext& Context, const UUpdatePkU32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI16(const FReducerEventContext& Context, const UUpdateUniqueOptionI16Reducer* Args) { - if (!OnUpdatePkU32.IsBound()) + if (!OnUpdateUniqueOptionI16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI16")); } return false; } - OnUpdatePkU32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU32WithArgs(const FReducerEventContext& Context, const FUpdatePkU32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI16Args& Args) { - if (!OnUpdatePkU32.IsBound()) + if (!OnUpdateUniqueOptionI16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI16")); } return false; } - OnUpdatePkU32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data) { if (!Conn) { @@ -12866,45 +16062,45 @@ void URemoteReducers::UpdatePkU32Two(const uint32 N, const int32 Data) return; } - FUpdatePkU32TwoArgs ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_32_two"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU32Two(ReducerArgs)); } + FUpdateUniqueOptionI256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU32Two(const FReducerEventContext& Context, const UUpdatePkU32TwoReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI256(const FReducerEventContext& Context, const UUpdateUniqueOptionI256Reducer* Args) { - if (!OnUpdatePkU32Two.IsBound()) + if (!OnUpdateUniqueOptionI256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI256")); } return false; } - OnUpdatePkU32Two.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU32TwoWithArgs(const FReducerEventContext& Context, const FUpdatePkU32TwoArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI256Args& Args) { - if (!OnUpdatePkU32Two.IsBound()) + if (!OnUpdateUniqueOptionI256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU32Two")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI256")); } return false; } - OnUpdatePkU32Two.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data) { if (!Conn) { @@ -12912,45 +16108,45 @@ void URemoteReducers::UpdatePkU64(const uint64 N, const int32 Data) return; } - FUpdatePkU64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU64(ReducerArgs)); } + FUpdateUniqueOptionI32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU64(const FReducerEventContext& Context, const UUpdatePkU64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI32(const FReducerEventContext& Context, const UUpdateUniqueOptionI32Reducer* Args) { - if (!OnUpdatePkU64.IsBound()) + if (!OnUpdateUniqueOptionI32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI32")); } return false; } - OnUpdatePkU64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU64WithArgs(const FReducerEventContext& Context, const FUpdatePkU64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI32Args& Args) { - if (!OnUpdatePkU64.IsBound()) + if (!OnUpdateUniqueOptionI32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI32")); } return false; } - OnUpdatePkU64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data) { if (!Conn) { @@ -12958,45 +16154,45 @@ void URemoteReducers::UpdatePkU8(const uint8 N, const int32 Data) return; } - FUpdatePkU8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_u_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkU8(ReducerArgs)); } + FUpdateUniqueOptionI64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkU8(const FReducerEventContext& Context, const UUpdatePkU8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI64(const FReducerEventContext& Context, const UUpdateUniqueOptionI64Reducer* Args) { - if (!OnUpdatePkU8.IsBound()) + if (!OnUpdateUniqueOptionI64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI64")); } return false; } - OnUpdatePkU8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionI64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkU8WithArgs(const FReducerEventContext& Context, const FUpdatePkU8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI64Args& Args) { - if (!OnUpdatePkU8.IsBound()) + if (!OnUpdateUniqueOptionI64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkU8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI64")); } return false; } - OnUpdatePkU8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionI64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) +void URemoteReducers::UpdateUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data) { if (!Conn) { @@ -13004,45 +16200,45 @@ void URemoteReducers::UpdatePkUuid(const FSpacetimeDBUuid& U, const int32 Data) return; } - FUpdatePkUuidArgs ReducerArgs(U, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_pk_uuid"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdatePkUuid(ReducerArgs)); } + FUpdateUniqueOptionI8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_i_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionI8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdatePkUuid(const FReducerEventContext& Context, const UUpdatePkUuidReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI8(const FReducerEventContext& Context, const UUpdateUniqueOptionI8Reducer* Args) { - if (!OnUpdatePkUuid.IsBound()) + if (!OnUpdateUniqueOptionI8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI8")); } return false; } - OnUpdatePkUuid.Broadcast(Context, Args->U, Args->Data); + OnUpdateUniqueOptionI8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdatePkUuidWithArgs(const FReducerEventContext& Context, const FUpdatePkUuidArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI8Args& Args) { - if (!OnUpdatePkUuid.IsBound()) + if (!OnUpdateUniqueOptionI8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdatePkUuid")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionI8")); } return false; } - OnUpdatePkUuid.Broadcast(Context, Args.U, Args.Data); + OnUpdateUniqueOptionI8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) +void URemoteReducers::UpdateUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data) { if (!Conn) { @@ -13050,45 +16246,45 @@ void URemoteReducers::UpdateUniqueBool(const bool B, const int32 Data) return; } - FUpdateUniqueBoolArgs ReducerArgs(B, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_bool"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueBool(ReducerArgs)); } + FUpdateUniqueOptionIdentityArgs ReducerArgs(I, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_identity"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionIdentity(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueBool(const FReducerEventContext& Context, const UUpdateUniqueBoolReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionIdentity(const FReducerEventContext& Context, const UUpdateUniqueOptionIdentityReducer* Args) { - if (!OnUpdateUniqueBool.IsBound()) + if (!OnUpdateUniqueOptionIdentity.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionIdentity")); } return false; } - OnUpdateUniqueBool.Broadcast(Context, Args->B, Args->Data); + OnUpdateUniqueOptionIdentity.Broadcast(Context, Args->I, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueBoolArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionIdentityArgs& Args) { - if (!OnUpdateUniqueBool.IsBound()) + if (!OnUpdateUniqueOptionIdentity.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueBool")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionIdentity")); } return false; } - OnUpdateUniqueBool.Broadcast(Context, Args.B, Args.Data); + OnUpdateUniqueOptionIdentity.Broadcast(Context, Args.I, Args.Data); return true; } -void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A, const int32 Data) +void URemoteReducers::UpdateUniqueOptionString(const FTestClientOptionalString& S, const int32 Data) { if (!Conn) { @@ -13096,45 +16292,45 @@ void URemoteReducers::UpdateUniqueConnectionId(const FSpacetimeDBConnectionId& A return; } - FUpdateUniqueConnectionIdArgs ReducerArgs(A, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_connection_id"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueConnectionId(ReducerArgs)); } + FUpdateUniqueOptionStringArgs ReducerArgs(S, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_string"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionString(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueConnectionId(const FReducerEventContext& Context, const UUpdateUniqueConnectionIdReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionString(const FReducerEventContext& Context, const UUpdateUniqueOptionStringReducer* Args) { - if (!OnUpdateUniqueConnectionId.IsBound()) + if (!OnUpdateUniqueOptionString.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionString")); } return false; } - OnUpdateUniqueConnectionId.Broadcast(Context, Args->A, Args->Data); + OnUpdateUniqueOptionString.Broadcast(Context, Args->S, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueConnectionIdArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionStringArgs& Args) { - if (!OnUpdateUniqueConnectionId.IsBound()) + if (!OnUpdateUniqueOptionString.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueConnectionId")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionString")); } return false; } - OnUpdateUniqueConnectionId.Broadcast(Context, Args.A, Args.Data); + OnUpdateUniqueOptionString.Broadcast(Context, Args.S, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data) { if (!Conn) { @@ -13142,45 +16338,45 @@ void URemoteReducers::UpdateUniqueI128(const FSpacetimeDBInt128& N, const int32 return; } - FUpdateUniqueI128Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_128"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI128(ReducerArgs)); } + FUpdateUniqueOptionU128Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_128"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU128(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI128(const FReducerEventContext& Context, const UUpdateUniqueI128Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU128(const FReducerEventContext& Context, const UUpdateUniqueOptionU128Reducer* Args) { - if (!OnUpdateUniqueI128.IsBound()) + if (!OnUpdateUniqueOptionU128.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU128")); } return false; } - OnUpdateUniqueI128.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU128.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI128Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU128Args& Args) { - if (!OnUpdateUniqueI128.IsBound()) + if (!OnUpdateUniqueOptionU128.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI128")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU128")); } return false; } - OnUpdateUniqueI128.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU128.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data) { if (!Conn) { @@ -13188,45 +16384,45 @@ void URemoteReducers::UpdateUniqueI16(const int16 N, const int32 Data) return; } - FUpdateUniqueI16Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_16"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI16(ReducerArgs)); } + FUpdateUniqueOptionU16Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_16"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU16(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI16(const FReducerEventContext& Context, const UUpdateUniqueI16Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU16(const FReducerEventContext& Context, const UUpdateUniqueOptionU16Reducer* Args) { - if (!OnUpdateUniqueI16.IsBound()) + if (!OnUpdateUniqueOptionU16.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU16")); } return false; } - OnUpdateUniqueI16.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU16.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI16Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU16Args& Args) { - if (!OnUpdateUniqueI16.IsBound()) + if (!OnUpdateUniqueOptionU16.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI16")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU16")); } return false; } - OnUpdateUniqueI16.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU16.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data) { if (!Conn) { @@ -13234,45 +16430,45 @@ void URemoteReducers::UpdateUniqueI256(const FSpacetimeDBInt256& N, const int32 return; } - FUpdateUniqueI256Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_256"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI256(ReducerArgs)); } + FUpdateUniqueOptionU256Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_256"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU256(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI256(const FReducerEventContext& Context, const UUpdateUniqueI256Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU256(const FReducerEventContext& Context, const UUpdateUniqueOptionU256Reducer* Args) { - if (!OnUpdateUniqueI256.IsBound()) + if (!OnUpdateUniqueOptionU256.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU256")); } return false; } - OnUpdateUniqueI256.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU256.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI256Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU256Args& Args) { - if (!OnUpdateUniqueI256.IsBound()) + if (!OnUpdateUniqueOptionU256.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI256")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU256")); } return false; } - OnUpdateUniqueI256.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU256.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data) { if (!Conn) { @@ -13280,45 +16476,45 @@ void URemoteReducers::UpdateUniqueI32(const int32 N, const int32 Data) return; } - FUpdateUniqueI32Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_32"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI32(ReducerArgs)); } + FUpdateUniqueOptionU32Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_32"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU32(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI32(const FReducerEventContext& Context, const UUpdateUniqueI32Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU32(const FReducerEventContext& Context, const UUpdateUniqueOptionU32Reducer* Args) { - if (!OnUpdateUniqueI32.IsBound()) + if (!OnUpdateUniqueOptionU32.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU32")); } return false; } - OnUpdateUniqueI32.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU32.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI32Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU32Args& Args) { - if (!OnUpdateUniqueI32.IsBound()) + if (!OnUpdateUniqueOptionU32.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI32")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU32")); } return false; } - OnUpdateUniqueI32.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU32.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data) { if (!Conn) { @@ -13326,45 +16522,45 @@ void URemoteReducers::UpdateUniqueI64(const int64 N, const int32 Data) return; } - FUpdateUniqueI64Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_64"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI64(ReducerArgs)); } + FUpdateUniqueOptionU64Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_64"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU64(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI64(const FReducerEventContext& Context, const UUpdateUniqueI64Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU64(const FReducerEventContext& Context, const UUpdateUniqueOptionU64Reducer* Args) { - if (!OnUpdateUniqueI64.IsBound()) + if (!OnUpdateUniqueOptionU64.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU64")); } return false; } - OnUpdateUniqueI64.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU64.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI64Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU64Args& Args) { - if (!OnUpdateUniqueI64.IsBound()) + if (!OnUpdateUniqueOptionU64.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI64")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU64")); } return false; } - OnUpdateUniqueI64.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU64.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) +void URemoteReducers::UpdateUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data) { if (!Conn) { @@ -13372,45 +16568,45 @@ void URemoteReducers::UpdateUniqueI8(const int8 N, const int32 Data) return; } - FUpdateUniqueI8Args ReducerArgs(N, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_i_8"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueI8(ReducerArgs)); } + FUpdateUniqueOptionU8Args ReducerArgs(N, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_u_8"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionU8(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueI8(const FReducerEventContext& Context, const UUpdateUniqueI8Reducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU8(const FReducerEventContext& Context, const UUpdateUniqueOptionU8Reducer* Args) { - if (!OnUpdateUniqueI8.IsBound()) + if (!OnUpdateUniqueOptionU8.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU8")); } return false; } - OnUpdateUniqueI8.Broadcast(Context, Args->N, Args->Data); + OnUpdateUniqueOptionU8.Broadcast(Context, Args->N, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueI8Args& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU8Args& Args) { - if (!OnUpdateUniqueI8.IsBound()) + if (!OnUpdateUniqueOptionU8.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueI8")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionU8")); } return false; } - OnUpdateUniqueI8.Broadcast(Context, Args.N, Args.Data); + OnUpdateUniqueOptionU8.Broadcast(Context, Args.N, Args.Data); return true; } -void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const int32 Data) +void URemoteReducers::UpdateUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data) { if (!Conn) { @@ -13418,41 +16614,41 @@ void URemoteReducers::UpdateUniqueIdentity(const FSpacetimeDBIdentity& I, const return; } - FUpdateUniqueIdentityArgs ReducerArgs(I, Data); - const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_identity"), ReducerArgs); - if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueIdentity(ReducerArgs)); } + FUpdateUniqueOptionUuidArgs ReducerArgs(U, Data); + const uint32 RequestId = Conn->CallReducerTyped(TEXT("update_unique_option_uuid"), ReducerArgs); + if (RequestId != 0) { Conn->RegisterPendingTypedReducer(RequestId, FReducer::UpdateUniqueOptionUuid(ReducerArgs)); } } -bool URemoteReducers::InvokeUpdateUniqueIdentity(const FReducerEventContext& Context, const UUpdateUniqueIdentityReducer* Args) +bool URemoteReducers::InvokeUpdateUniqueOptionUuid(const FReducerEventContext& Context, const UUpdateUniqueOptionUuidReducer* Args) { - if (!OnUpdateUniqueIdentity.IsBound()) + if (!OnUpdateUniqueOptionUuid.IsBound()) { // Handle unhandled reducer error if (InternalOnUnhandledReducerError.IsBound()) { // TODO: Check Context.Event.Status for Failed/OutOfEnergy cases // For now, just broadcast any error - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionUuid")); } return false; } - OnUpdateUniqueIdentity.Broadcast(Context, Args->I, Args->Data); + OnUpdateUniqueOptionUuid.Broadcast(Context, Args->U, Args->Data); return true; } -bool URemoteReducers::InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args) +bool URemoteReducers::InvokeUpdateUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionUuidArgs& Args) { - if (!OnUpdateUniqueIdentity.IsBound()) + if (!OnUpdateUniqueOptionUuid.IsBound()) { if (InternalOnUnhandledReducerError.IsBound()) { - InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueIdentity")); + InternalOnUnhandledReducerError.Broadcast(Context, TEXT("No handler registered for UpdateUniqueOptionUuid")); } return false; } - OnUpdateUniqueIdentity.Broadcast(Context, Args.I, Args.Data); + OnUpdateUniqueOptionUuid.Broadcast(Context, Args.U, Args.Data); return true; } @@ -14265,6 +17461,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeDeleteAllUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("delete_all_unique_option_bool")) + { + FDeleteAllUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionBool(); + Reducers->InvokeDeleteAllUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_connection_id")) + { + FDeleteAllUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionConnectionId(); + Reducers->InvokeDeleteAllUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_128")) + { + FDeleteAllUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI128(); + Reducers->InvokeDeleteAllUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_16")) + { + FDeleteAllUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI16(); + Reducers->InvokeDeleteAllUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_256")) + { + FDeleteAllUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI256(); + Reducers->InvokeDeleteAllUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_32")) + { + FDeleteAllUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI32(); + Reducers->InvokeDeleteAllUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_64")) + { + FDeleteAllUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI64(); + Reducers->InvokeDeleteAllUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_i_8")) + { + FDeleteAllUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionI8(); + Reducers->InvokeDeleteAllUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_identity")) + { + FDeleteAllUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionIdentity(); + Reducers->InvokeDeleteAllUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_string")) + { + FDeleteAllUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionString(); + Reducers->InvokeDeleteAllUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_128")) + { + FDeleteAllUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU128(); + Reducers->InvokeDeleteAllUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_16")) + { + FDeleteAllUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU16(); + Reducers->InvokeDeleteAllUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_256")) + { + FDeleteAllUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU256(); + Reducers->InvokeDeleteAllUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_32")) + { + FDeleteAllUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU32(); + Reducers->InvokeDeleteAllUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_64")) + { + FDeleteAllUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU64(); + Reducers->InvokeDeleteAllUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_u_8")) + { + FDeleteAllUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionU8(); + Reducers->InvokeDeleteAllUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_all_unique_option_uuid")) + { + FDeleteAllUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueOptionUuid(); + Reducers->InvokeDeleteAllUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("delete_all_unique_string")) { FDeleteAllUniqueStringArgs Args = ReducerEvent.Reducer.GetAsDeleteAllUniqueString(); @@ -14573,74 +17871,176 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) } if (ReducerName == TEXT("delete_pk_u_64")) { - FDeletePkU64Args Args = ReducerEvent.Reducer.GetAsDeletePkU64(); - Reducers->InvokeDeletePkU64WithArgs(Context, Args); + FDeletePkU64Args Args = ReducerEvent.Reducer.GetAsDeletePkU64(); + Reducers->InvokeDeletePkU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_pk_u_8")) + { + FDeletePkU8Args Args = ReducerEvent.Reducer.GetAsDeletePkU8(); + Reducers->InvokeDeletePkU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_pk_uuid")) + { + FDeletePkUuidArgs Args = ReducerEvent.Reducer.GetAsDeletePkUuid(); + Reducers->InvokeDeletePkUuidWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_bool")) + { + FDeleteUniqueBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueBool(); + Reducers->InvokeDeleteUniqueBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_connection_id")) + { + FDeleteUniqueConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueConnectionId(); + Reducers->InvokeDeleteUniqueConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_128")) + { + FDeleteUniqueI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI128(); + Reducers->InvokeDeleteUniqueI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_16")) + { + FDeleteUniqueI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI16(); + Reducers->InvokeDeleteUniqueI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_256")) + { + FDeleteUniqueI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI256(); + Reducers->InvokeDeleteUniqueI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_32")) + { + FDeleteUniqueI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI32(); + Reducers->InvokeDeleteUniqueI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_64")) + { + FDeleteUniqueI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI64(); + Reducers->InvokeDeleteUniqueI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_i_8")) + { + FDeleteUniqueI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI8(); + Reducers->InvokeDeleteUniqueI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_identity")) + { + FDeleteUniqueIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueIdentity(); + Reducers->InvokeDeleteUniqueIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_bool")) + { + FDeleteUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionBool(); + Reducers->InvokeDeleteUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_connection_id")) + { + FDeleteUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionConnectionId(); + Reducers->InvokeDeleteUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_128")) + { + FDeleteUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI128(); + Reducers->InvokeDeleteUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_16")) + { + FDeleteUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI16(); + Reducers->InvokeDeleteUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_256")) + { + FDeleteUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI256(); + Reducers->InvokeDeleteUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("delete_unique_option_i_32")) + { + FDeleteUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI32(); + Reducers->InvokeDeleteUniqueOptionI32WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_pk_u_8")) + if (ReducerName == TEXT("delete_unique_option_i_64")) { - FDeletePkU8Args Args = ReducerEvent.Reducer.GetAsDeletePkU8(); - Reducers->InvokeDeletePkU8WithArgs(Context, Args); + FDeleteUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI64(); + Reducers->InvokeDeleteUniqueOptionI64WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_pk_uuid")) + if (ReducerName == TEXT("delete_unique_option_i_8")) { - FDeletePkUuidArgs Args = ReducerEvent.Reducer.GetAsDeletePkUuid(); - Reducers->InvokeDeletePkUuidWithArgs(Context, Args); + FDeleteUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionI8(); + Reducers->InvokeDeleteUniqueOptionI8WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_bool")) + if (ReducerName == TEXT("delete_unique_option_identity")) { - FDeleteUniqueBoolArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueBool(); - Reducers->InvokeDeleteUniqueBoolWithArgs(Context, Args); + FDeleteUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionIdentity(); + Reducers->InvokeDeleteUniqueOptionIdentityWithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_connection_id")) + if (ReducerName == TEXT("delete_unique_option_string")) { - FDeleteUniqueConnectionIdArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueConnectionId(); - Reducers->InvokeDeleteUniqueConnectionIdWithArgs(Context, Args); + FDeleteUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionString(); + Reducers->InvokeDeleteUniqueOptionStringWithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_128")) + if (ReducerName == TEXT("delete_unique_option_u_128")) { - FDeleteUniqueI128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI128(); - Reducers->InvokeDeleteUniqueI128WithArgs(Context, Args); + FDeleteUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU128(); + Reducers->InvokeDeleteUniqueOptionU128WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_16")) + if (ReducerName == TEXT("delete_unique_option_u_16")) { - FDeleteUniqueI16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI16(); - Reducers->InvokeDeleteUniqueI16WithArgs(Context, Args); + FDeleteUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU16(); + Reducers->InvokeDeleteUniqueOptionU16WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_256")) + if (ReducerName == TEXT("delete_unique_option_u_256")) { - FDeleteUniqueI256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI256(); - Reducers->InvokeDeleteUniqueI256WithArgs(Context, Args); + FDeleteUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU256(); + Reducers->InvokeDeleteUniqueOptionU256WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_32")) + if (ReducerName == TEXT("delete_unique_option_u_32")) { - FDeleteUniqueI32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI32(); - Reducers->InvokeDeleteUniqueI32WithArgs(Context, Args); + FDeleteUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU32(); + Reducers->InvokeDeleteUniqueOptionU32WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_64")) + if (ReducerName == TEXT("delete_unique_option_u_64")) { - FDeleteUniqueI64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI64(); - Reducers->InvokeDeleteUniqueI64WithArgs(Context, Args); + FDeleteUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU64(); + Reducers->InvokeDeleteUniqueOptionU64WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_i_8")) + if (ReducerName == TEXT("delete_unique_option_u_8")) { - FDeleteUniqueI8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueI8(); - Reducers->InvokeDeleteUniqueI8WithArgs(Context, Args); + FDeleteUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionU8(); + Reducers->InvokeDeleteUniqueOptionU8WithArgs(Context, Args); return; } - if (ReducerName == TEXT("delete_unique_identity")) + if (ReducerName == TEXT("delete_unique_option_uuid")) { - FDeleteUniqueIdentityArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueIdentity(); - Reducers->InvokeDeleteUniqueIdentityWithArgs(Context, Args); + FDeleteUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsDeleteUniqueOptionUuid(); + Reducers->InvokeDeleteUniqueOptionUuidWithArgs(Context, Args); return; } if (ReducerName == TEXT("delete_unique_string")) @@ -15195,6 +18595,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeInsertUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("insert_unique_option_bool")) + { + FInsertUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionBool(); + Reducers->InvokeInsertUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_connection_id")) + { + FInsertUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionConnectionId(); + Reducers->InvokeInsertUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_128")) + { + FInsertUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI128(); + Reducers->InvokeInsertUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_16")) + { + FInsertUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI16(); + Reducers->InvokeInsertUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_256")) + { + FInsertUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI256(); + Reducers->InvokeInsertUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_32")) + { + FInsertUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI32(); + Reducers->InvokeInsertUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_64")) + { + FInsertUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI64(); + Reducers->InvokeInsertUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_i_8")) + { + FInsertUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionI8(); + Reducers->InvokeInsertUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_identity")) + { + FInsertUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionIdentity(); + Reducers->InvokeInsertUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_string")) + { + FInsertUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionString(); + Reducers->InvokeInsertUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_128")) + { + FInsertUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU128(); + Reducers->InvokeInsertUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_16")) + { + FInsertUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU16(); + Reducers->InvokeInsertUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_256")) + { + FInsertUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU256(); + Reducers->InvokeInsertUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_32")) + { + FInsertUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU32(); + Reducers->InvokeInsertUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_64")) + { + FInsertUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU64(); + Reducers->InvokeInsertUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_u_8")) + { + FInsertUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionU8(); + Reducers->InvokeInsertUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("insert_unique_option_uuid")) + { + FInsertUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueOptionUuid(); + Reducers->InvokeInsertUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("insert_unique_string")) { FInsertUniqueStringArgs Args = ReducerEvent.Reducer.GetAsInsertUniqueString(); @@ -15597,6 +19099,108 @@ void UDbConnection::ReducerEvent(const FReducerEvent& Event) Reducers->InvokeUpdateUniqueIdentityWithArgs(Context, Args); return; } + if (ReducerName == TEXT("update_unique_option_bool")) + { + FUpdateUniqueOptionBoolArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionBool(); + Reducers->InvokeUpdateUniqueOptionBoolWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_connection_id")) + { + FUpdateUniqueOptionConnectionIdArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionConnectionId(); + Reducers->InvokeUpdateUniqueOptionConnectionIdWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_128")) + { + FUpdateUniqueOptionI128Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI128(); + Reducers->InvokeUpdateUniqueOptionI128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_16")) + { + FUpdateUniqueOptionI16Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI16(); + Reducers->InvokeUpdateUniqueOptionI16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_256")) + { + FUpdateUniqueOptionI256Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI256(); + Reducers->InvokeUpdateUniqueOptionI256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_32")) + { + FUpdateUniqueOptionI32Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI32(); + Reducers->InvokeUpdateUniqueOptionI32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_64")) + { + FUpdateUniqueOptionI64Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI64(); + Reducers->InvokeUpdateUniqueOptionI64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_i_8")) + { + FUpdateUniqueOptionI8Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionI8(); + Reducers->InvokeUpdateUniqueOptionI8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_identity")) + { + FUpdateUniqueOptionIdentityArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionIdentity(); + Reducers->InvokeUpdateUniqueOptionIdentityWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_string")) + { + FUpdateUniqueOptionStringArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionString(); + Reducers->InvokeUpdateUniqueOptionStringWithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_128")) + { + FUpdateUniqueOptionU128Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU128(); + Reducers->InvokeUpdateUniqueOptionU128WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_16")) + { + FUpdateUniqueOptionU16Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU16(); + Reducers->InvokeUpdateUniqueOptionU16WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_256")) + { + FUpdateUniqueOptionU256Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU256(); + Reducers->InvokeUpdateUniqueOptionU256WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_32")) + { + FUpdateUniqueOptionU32Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU32(); + Reducers->InvokeUpdateUniqueOptionU32WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_64")) + { + FUpdateUniqueOptionU64Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU64(); + Reducers->InvokeUpdateUniqueOptionU64WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_u_8")) + { + FUpdateUniqueOptionU8Args Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionU8(); + Reducers->InvokeUpdateUniqueOptionU8WithArgs(Context, Args); + return; + } + if (ReducerName == TEXT("update_unique_option_uuid")) + { + FUpdateUniqueOptionUuidArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueOptionUuid(); + Reducers->InvokeUpdateUniqueOptionUuidWithArgs(Context, Args); + return; + } if (ReducerName == TEXT("update_unique_string")) { FUpdateUniqueStringArgs Args = ReducerEvent.Reducer.GetAsUpdateUniqueString(); @@ -16323,6 +19927,142 @@ USubscriptionBuilder* USubscriptionBuilder::AddUniqueIdentityQuery(const FUnique return AddBlueprintQuery(GenericQuery); } +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionBoolQuery(const FUniqueOptionBoolQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionConnectionIdQuery(const FUniqueOptionConnectionIdQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI128Query(const FUniqueOptionI128Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI16Query(const FUniqueOptionI16Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI256Query(const FUniqueOptionI256Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI32Query(const FUniqueOptionI32Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI64Query(const FUniqueOptionI64Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionI8Query(const FUniqueOptionI8Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionIdentityQuery(const FUniqueOptionIdentityQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionStringQuery(const FUniqueOptionStringQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU128Query(const FUniqueOptionU128Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU16Query(const FUniqueOptionU16Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU256Query(const FUniqueOptionU256Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU32Query(const FUniqueOptionU32Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU64Query(const FUniqueOptionU64Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionU8Query(const FUniqueOptionU8Query& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + +USubscriptionBuilder* USubscriptionBuilder::AddUniqueOptionUuidQuery(const FUniqueOptionUuidQuery& Query) +{ + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return AddBlueprintQuery(GenericQuery); +} + USubscriptionBuilder* USubscriptionBuilder::AddUniqueStringQuery(const FUniqueStringQuery& Query) { FBlueprintQuery GenericQuery; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp new file mode 100644 index 00000000000..c49fef259e2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionBoolTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionBoolTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionBoolTable = Data->GetOrAdd(TableName); + UniqueOptionBoolTable->AddUniqueConstraint("b", [](const FUniqueOptionBoolType& Row) -> const FTestClientOptionalBool& { + return Row.B; }); + + B = NewObject(this); + B->SetCache(UniqueOptionBoolTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionBoolTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionBoolTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionBoolTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp new file mode 100644 index 00000000000..70aef30a695 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionConnectionIdTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionConnectionIdTable = Data->GetOrAdd(TableName); + UniqueOptionConnectionIdTable->AddUniqueConstraint("a", [](const FUniqueOptionConnectionIdType& Row) -> const FTestClientOptionalConnectionId& { + return Row.A; }); + + A = NewObject(this); + A->SetCache(UniqueOptionConnectionIdTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionConnectionIdTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionConnectionIdTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionConnectionIdTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp new file mode 100644 index 00000000000..0a8cd068bc8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI128Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI128Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI128Table = Data->GetOrAdd(TableName); + UniqueOptionI128Table->AddUniqueConstraint("n", [](const FUniqueOptionI128Type& Row) -> const FTestClientOptionalInt128& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI128Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI128Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI128Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI128Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp new file mode 100644 index 00000000000..a389db49a50 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI16Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI16Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI16Table = Data->GetOrAdd(TableName); + UniqueOptionI16Table->AddUniqueConstraint("n", [](const FUniqueOptionI16Type& Row) -> const FTestClientOptionalInt16& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI16Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI16Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI16Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI16Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp new file mode 100644 index 00000000000..efb9c5a5c9a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI256Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI256Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI256Table = Data->GetOrAdd(TableName); + UniqueOptionI256Table->AddUniqueConstraint("n", [](const FUniqueOptionI256Type& Row) -> const FTestClientOptionalInt256& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI256Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI256Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI256Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI256Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp new file mode 100644 index 00000000000..840084df71e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI32Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI32Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI32Table = Data->GetOrAdd(TableName); + UniqueOptionI32Table->AddUniqueConstraint("n", [](const FUniqueOptionI32Type& Row) -> const FTestClientOptionalInt32& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI32Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI32Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI32Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI32Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp new file mode 100644 index 00000000000..139f9daf72d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI64Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI64Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI64Table = Data->GetOrAdd(TableName); + UniqueOptionI64Table->AddUniqueConstraint("n", [](const FUniqueOptionI64Type& Row) -> const FTestClientOptionalInt64& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI64Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI64Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI64Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI64Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp new file mode 100644 index 00000000000..747d65726f1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionI8Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionI8Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionI8Table = Data->GetOrAdd(TableName); + UniqueOptionI8Table->AddUniqueConstraint("n", [](const FUniqueOptionI8Type& Row) -> const FTestClientOptionalInt8& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionI8Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionI8Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionI8Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionI8Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp new file mode 100644 index 00000000000..3d5ea6a6122 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionIdentityTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionIdentityTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionIdentityTable = Data->GetOrAdd(TableName); + UniqueOptionIdentityTable->AddUniqueConstraint("i", [](const FUniqueOptionIdentityType& Row) -> const FTestClientOptionalIdentity& { + return Row.I; }); + + I = NewObject(this); + I->SetCache(UniqueOptionIdentityTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionIdentityTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionIdentityTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionIdentityTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp new file mode 100644 index 00000000000..b660d54d0df --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionStringTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionStringTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionStringTable = Data->GetOrAdd(TableName); + UniqueOptionStringTable->AddUniqueConstraint("s", [](const FUniqueOptionStringType& Row) -> const FTestClientOptionalString& { + return Row.S; }); + + S = NewObject(this); + S->SetCache(UniqueOptionStringTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionStringTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionStringTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionStringTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp new file mode 100644 index 00000000000..46faeee1454 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU128Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU128Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU128Table = Data->GetOrAdd(TableName); + UniqueOptionU128Table->AddUniqueConstraint("n", [](const FUniqueOptionU128Type& Row) -> const FTestClientOptionalUInt128& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU128Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU128Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU128Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU128Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp new file mode 100644 index 00000000000..89c1d168bec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU16Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU16Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU16Table = Data->GetOrAdd(TableName); + UniqueOptionU16Table->AddUniqueConstraint("n", [](const FUniqueOptionU16Type& Row) -> const FTestClientOptionalUInt16& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU16Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU16Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU16Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU16Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp new file mode 100644 index 00000000000..c06864a9589 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU256Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU256Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU256Table = Data->GetOrAdd(TableName); + UniqueOptionU256Table->AddUniqueConstraint("n", [](const FUniqueOptionU256Type& Row) -> const FTestClientOptionalUInt256& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU256Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU256Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU256Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU256Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp new file mode 100644 index 00000000000..3cc7af4ef1d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU32Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU32Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU32Table = Data->GetOrAdd(TableName); + UniqueOptionU32Table->AddUniqueConstraint("n", [](const FUniqueOptionU32Type& Row) -> const FTestClientOptionalUInt32& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU32Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU32Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU32Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU32Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp new file mode 100644 index 00000000000..140e449a2bb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU64Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU64Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU64Table = Data->GetOrAdd(TableName); + UniqueOptionU64Table->AddUniqueConstraint("n", [](const FUniqueOptionU64Type& Row) -> const FTestClientOptionalUInt64& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU64Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU64Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU64Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU64Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp new file mode 100644 index 00000000000..9cc53b5d9a2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionU8Table.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionU8Table::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionU8Table = Data->GetOrAdd(TableName); + UniqueOptionU8Table->AddUniqueConstraint("n", [](const FUniqueOptionU8Type& Row) -> const FTestClientOptionalUInt8& { + return Row.N; }); + + N = NewObject(this); + N->SetCache(UniqueOptionU8Table); + + /***/ +} + +FTableAppliedDiff UUniqueOptionU8Table::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionU8Table::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionU8Table::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp new file mode 100644 index 00000000000..f2c83b72942 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/UniqueOptionUuidTable.g.cpp @@ -0,0 +1,40 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" +#include "DBCache/UniqueIndex.h" +#include "DBCache/BTreeUniqueIndex.h" +#include "DBCache/ClientCache.h" +#include "DBCache/TableCache.h" + +void UUniqueOptionUuidTable::PostInitialize() +{ + /** Client cache init and setting up indexes*/ + Data = MakeShared>(); + + TSharedPtr> UniqueOptionUuidTable = Data->GetOrAdd(TableName); + UniqueOptionUuidTable->AddUniqueConstraint("u", [](const FUniqueOptionUuidType& Row) -> const FTestClientOptionalUuid& { + return Row.U; }); + + U = NewObject(this); + U->SetCache(UniqueOptionUuidTable); + + /***/ +} + +FTableAppliedDiff UUniqueOptionUuidTable::Update(TArray> InsertsRef, TArray> DeletesRef) +{ + FTableAppliedDiff Diff = BaseUpdate(InsertsRef, DeletesRef, Data, TableName); + + return Diff; +} + +int32 UUniqueOptionUuidTable::Count() const +{ + return GetRowCountFromTable(Data, TableName); +} + +TArray UUniqueOptionUuidTable::Iter() const +{ + return GetAllRowsFromTable(Data, TableName); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp index b66fa452282..17709481e45 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/SpacetimeFullClientTests.cpp @@ -1187,6 +1187,74 @@ bool FInsertOptionNoneTest::RunTest(const FString &Parameters) return true; } +bool FDeleteOptionSomeTest::RunTest(const FString &Parameters) +{ + TestName = "DeleteOptionSome"; + + if (!ValidateParameterConfig(this)) + return false; + UDeleteOptionHandler *Handler = CreateTestHandler(); + Handler->bUseSome = true; + +#define REG_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Handler->Counter->Register(TEXT("InsertUniqueOption" #Suffix)); \ + Handler->Counter->Register(TEXT("DeleteUniqueOption" #Suffix)); + FOREACH_UNIQUE_OPTION_PRIMITIVE(REG_UNIQUE_OPTION) +#undef REG_UNIQUE_OPTION + + UDbConnection *Connection = ConnectThen(Handler->Counter, TestName, [this, Handler](UDbConnection *Conn) + { +#define BIND_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Conn->Db->UniqueOption##Suffix->OnInsert.AddDynamic(Handler, &UDeleteOptionHandler::OnInsertUniqueOption##Suffix); \ + Conn->Db->UniqueOption##Suffix->OnDelete.AddDynamic(Handler, &UDeleteOptionHandler::OnDeleteUniqueOption##Suffix); + FOREACH_UNIQUE_OPTION_PRIMITIVE(BIND_UNIQUE_OPTION) +#undef BIND_UNIQUE_OPTION + + SubscribeAllThen(Conn, [Handler](FSubscriptionEventContext Ctx) + { +#define CALL_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) Ctx.Reducers->InsertUniqueOption##Suffix(SomeLiteral, Expected); + FOREACH_UNIQUE_OPTION_PRIMITIVE(CALL_UNIQUE_OPTION) +#undef CALL_UNIQUE_OPTION + }); }); + + ADD_LATENT_AUTOMATION_COMMAND(FWaitForTestCounter(*this, TestName, Handler->Counter, FPlatformTime::Seconds())); + return true; +} + +bool FDeleteOptionNoneTest::RunTest(const FString &Parameters) +{ + TestName = "DeleteOptionNone"; + + if (!ValidateParameterConfig(this)) + return false; + UDeleteOptionHandler *Handler = CreateTestHandler(); + Handler->bUseSome = false; + +#define REG_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Handler->Counter->Register(TEXT("InsertUniqueOption" #Suffix)); \ + Handler->Counter->Register(TEXT("DeleteUniqueOption" #Suffix)); + FOREACH_UNIQUE_OPTION_PRIMITIVE(REG_UNIQUE_OPTION) +#undef REG_UNIQUE_OPTION + + UDbConnection *Connection = ConnectThen(Handler->Counter, TestName, [this, Handler](UDbConnection *Conn) + { +#define BIND_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ + Conn->Db->UniqueOption##Suffix->OnInsert.AddDynamic(Handler, &UDeleteOptionHandler::OnInsertUniqueOption##Suffix); \ + Conn->Db->UniqueOption##Suffix->OnDelete.AddDynamic(Handler, &UDeleteOptionHandler::OnDeleteUniqueOption##Suffix); + FOREACH_UNIQUE_OPTION_PRIMITIVE(BIND_UNIQUE_OPTION) +#undef BIND_UNIQUE_OPTION + + SubscribeAllThen(Conn, [Handler](FSubscriptionEventContext Ctx) + { +#define CALL_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) Ctx.Reducers->InsertUniqueOption##Suffix(NoneLiteral, Expected); + FOREACH_UNIQUE_OPTION_PRIMITIVE(CALL_UNIQUE_OPTION) +#undef CALL_UNIQUE_OPTION + }); }); + + ADD_LATENT_AUTOMATION_COMMAND(FWaitForTestCounter(*this, TestName, Handler->Counter, FPlatformTime::Seconds())); + return true; +} + bool FInsertResultOkTest::RunTest(const FString &Parameters) { TestName = "InsertResultOk"; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp index 553f722e566..e3e346339a1 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/Tests/TestHandler.cpp @@ -50,6 +50,34 @@ void UDeletePrimitiveHandler::OnDeleteUnique##Suffix(const FEventContext& Contex FOREACH_UNIQUE_PRIMITIVE(DEFINE_DELETE_UNIQUE) #undef DEFINE_DELETE_UNIQUE +/* DeleteOption handler functions --------------------------------------- */ +#define DEFINE_DELETE_UNIQUE_OPTION(Suffix, Field, SomeLiteral, NoneLiteral, Expected, RowStructType) \ +void UDeleteOptionHandler::OnInsertUniqueOption##Suffix(const FEventContext& Context, const RowStructType& Value) \ +{ \ + static const FString Name(TEXT("InsertUniqueOption" #Suffix)); \ + RowStructType ExpectedValue; \ + ExpectedValue.Field = bUseSome ? SomeLiteral : NoneLiteral; \ + ExpectedValue.Data = Expected; \ + if (Value == ExpectedValue) { \ + Counter->MarkSuccess(Name); \ + } else { \ + Counter->MarkFailure(Name, TEXT("Unexpected value")); \ + } \ + Context.Reducers->DeleteUniqueOption##Suffix(Value.Field); \ +} \ + \ +void UDeleteOptionHandler::OnDeleteUniqueOption##Suffix(const FEventContext& Context, const RowStructType& Value) \ +{ \ + static const FString Name(TEXT("DeleteUniqueOption" #Suffix)); \ + RowStructType ExpectedValue; \ + ExpectedValue.Field = bUseSome ? SomeLiteral : NoneLiteral; \ + ExpectedValue.Data = Expected; \ + (Value == ExpectedValue) ? Counter->MarkSuccess(Name) : Counter->MarkFailure(Name, TEXT("Unexpected value")); \ +} + +FOREACH_UNIQUE_OPTION_PRIMITIVE(DEFINE_DELETE_UNIQUE_OPTION) +#undef DEFINE_DELETE_UNIQUE_OPTION + /* UpdatePrimitive handler functions ------------------------------------ */ #define DEFINE_UPDATE_PK(Suffix, Field, Literal, Expected, Updated, RowStructType) \ void UUpdatePrimitiveHandler::OnInsertPk##Suffix(const FEventContext& Context, const RowStructType& Value) \ diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h new file mode 100644 index 00000000000..c3a7d71e08d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalBool.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalBool.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalBool +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + bool Value = {}; + + FTestClientOptionalBool() = default; + + explicit FTestClientOptionalBool(const bool& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalBool& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalBool& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalBool. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalBool instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalBool& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalBool); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalBool, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h new file mode 100644 index 00000000000..ac323fb8e64 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "TestClientOptionalConnectionId.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalConnectionId +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBConnectionId Value = {}; + + FTestClientOptionalConnectionId() = default; + + explicit FTestClientOptionalConnectionId(const FSpacetimeDBConnectionId& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalConnectionId& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalConnectionId& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalConnectionId. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalConnectionId instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalConnectionId& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalConnectionId); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalConnectionId, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h new file mode 100644 index 00000000000..c3a62450005 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt128.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalInt128.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt128 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBInt128 Value = {}; + + FTestClientOptionalInt128() = default; + + explicit FTestClientOptionalInt128(const FSpacetimeDBInt128& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt128& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt128& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt128. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt128 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt128& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt128); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt128, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h new file mode 100644 index 00000000000..195106c8f66 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt16.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt16.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt16 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: int16 field not exposed to Blueprint due to non-blueprintable elements + int16 Value = {}; + + FTestClientOptionalInt16() = default; + + explicit FTestClientOptionalInt16(const int16& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt16& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt16& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt16. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt16 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt16& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt16); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt16, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h new file mode 100644 index 00000000000..542b52566c9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt256.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalInt256.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt256 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBInt256 Value = {}; + + FTestClientOptionalInt256() = default; + + explicit FTestClientOptionalInt256(const FSpacetimeDBInt256& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt256& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt256& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt256. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt256 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt256& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt256); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt256, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h new file mode 100644 index 00000000000..95967bd3dec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt64.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt64.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt64 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + int64 Value = {}; + + FTestClientOptionalInt64() = default; + + explicit FTestClientOptionalInt64(const int64& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt64& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt64& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt64. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt64 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt64& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt64); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt64, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h new file mode 100644 index 00000000000..6f84152a93b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalInt8.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalInt8.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalInt8 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: int8 field not exposed to Blueprint due to non-blueprintable elements + int8 Value = {}; + + FTestClientOptionalInt8() = default; + + explicit FTestClientOptionalInt8(const int8& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalInt8& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalInt8& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalInt8. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalInt8 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalInt8& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalInt8); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalInt8, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h new file mode 100644 index 00000000000..40eab608920 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt128.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalUInt128.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt128 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBUInt128 Value = {}; + + FTestClientOptionalUInt128() = default; + + explicit FTestClientOptionalUInt128(const FSpacetimeDBUInt128& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt128& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt128& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt128. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt128 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt128& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt128); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt128, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h new file mode 100644 index 00000000000..f7535a3e5ec --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt16.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt16.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt16 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint16 field not exposed to Blueprint due to non-blueprintable elements + uint16 Value = {}; + + FTestClientOptionalUInt16() = default; + + explicit FTestClientOptionalUInt16(const uint16& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt16& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt16& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt16. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt16 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt16& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt16); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt16, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h new file mode 100644 index 00000000000..1fbe787abb5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt256.g.h @@ -0,0 +1,62 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/LargeIntegers.h" +#include "TestClientOptionalUInt256.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt256 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + FSpacetimeDBUInt256 Value = {}; + + FTestClientOptionalUInt256() = default; + + explicit FTestClientOptionalUInt256(const FSpacetimeDBUInt256& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt256& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt256& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt256. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt256 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt256& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt256); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt256, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h new file mode 100644 index 00000000000..573e8a3a25a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt32.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt32.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt32 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint32 field not exposed to Blueprint due to non-blueprintable elements + uint32 Value = {}; + + FTestClientOptionalUInt32() = default; + + explicit FTestClientOptionalUInt32(const uint32& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt32& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt32& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt32. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt32 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt32& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt32); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt32, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h new file mode 100644 index 00000000000..c7553763d94 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt64.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt64.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt64 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + // NOTE: uint64 field not exposed to Blueprint due to non-blueprintable elements + uint64 Value = {}; + + FTestClientOptionalUInt64() = default; + + explicit FTestClientOptionalUInt64(const uint64& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt64& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt64& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt64. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt64 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt64& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt64); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt64, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h new file mode 100644 index 00000000000..266d3c68793 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Optionals/TestClientOptionalUInt8.g.h @@ -0,0 +1,61 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "TestClientOptionalUInt8.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientOptionalUInt8 +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + bool bHasValue = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB", meta = (EditCondition = "bHasValue")) + uint8 Value = {}; + + FTestClientOptionalUInt8() = default; + + explicit FTestClientOptionalUInt8(const uint8& InValue) + : bHasValue(true), Value(InValue) {} + + bool IsSet() const { return bHasValue; } + void Reset() { bHasValue = false; } + + FORCEINLINE bool operator==(const FTestClientOptionalUInt8& Other) const + { + if (bHasValue != Other.bHasValue) return false; + return !bHasValue || Value == Other.Value; + } + + FORCEINLINE bool operator!=(const FTestClientOptionalUInt8& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FTestClientOptionalUInt8. + * Hashes the HasValue flag and the Value if present. + * @param Optional The FTestClientOptionalUInt8 instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FTestClientOptionalUInt8& Optional) +{ + uint32 Hash = GetTypeHash(Optional.bHasValue); + if (Optional.bHasValue) + { + Hash = HashCombine(Hash, GetTypeHash(Optional.Value)); + } + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FTestClientOptionalUInt8); + + UE_SPACETIMEDB_OPTIONAL(FTestClientOptionalUInt8, bHasValue, Value); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h new file mode 100644 index 00000000000..9a98e49302a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionBoolArgs() = default; + + FDeleteAllUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..fe1de2f438e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionConnectionIdArgs() = default; + + FDeleteAllUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h new file mode 100644 index 00000000000..5f8496555b1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI128Args() = default; + + FDeleteAllUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h new file mode 100644 index 00000000000..baa235ee5bb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI16Args() = default; + + FDeleteAllUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h new file mode 100644 index 00000000000..21e9ffd0e8b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI256Args() = default; + + FDeleteAllUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h new file mode 100644 index 00000000000..633f9ed0980 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI32Args() = default; + + FDeleteAllUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h new file mode 100644 index 00000000000..37c6d5271b9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI64Args() = default; + + FDeleteAllUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h new file mode 100644 index 00000000000..1a1fd866af6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionI8Args() = default; + + FDeleteAllUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..9eca8e44b97 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionIdentityArgs() = default; + + FDeleteAllUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h new file mode 100644 index 00000000000..3556cac30b6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionString.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionStringArgs() = default; + + FDeleteAllUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h new file mode 100644 index 00000000000..3f53500e187 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU128Args() = default; + + FDeleteAllUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h new file mode 100644 index 00000000000..4f33ae25547 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU16Args() = default; + + FDeleteAllUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h new file mode 100644 index 00000000000..c80dc002d35 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU256Args() = default; + + FDeleteAllUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h new file mode 100644 index 00000000000..8494a4ce777 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU32Args() = default; + + FDeleteAllUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h new file mode 100644 index 00000000000..ff1ba95d537 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU64Args() = default; + + FDeleteAllUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h new file mode 100644 index 00000000000..1da4417e0f9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteAllUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionU8Args() = default; + + FDeleteAllUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h new file mode 100644 index 00000000000..5e6e9d382f8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteAllUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for DeleteAllUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteAllUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FDeleteAllUniqueOptionUuidArgs() = default; + + FDeleteAllUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FDeleteAllUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FDeleteAllUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteAllUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteAllUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h new file mode 100644 index 00000000000..e7ee9ea966c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + FDeleteUniqueOptionBoolArgs() = default; + + FDeleteUniqueOptionBoolArgs(const FTestClientOptionalBool& InB) + : B(InB) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionBoolArgs& Other) const + { + return B == Other.B; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionBoolArgs, B); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..41d7f91fc12 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + FDeleteUniqueOptionConnectionIdArgs() = default; + + FDeleteUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA) + : A(InA) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionConnectionIdArgs, A); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h new file mode 100644 index 00000000000..d2221b649a9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + FDeleteUniqueOptionI128Args() = default; + + FDeleteUniqueOptionI128Args(const FTestClientOptionalInt128& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI128Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI128Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h new file mode 100644 index 00000000000..4c250f2371e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + FDeleteUniqueOptionI16Args() = default; + + FDeleteUniqueOptionI16Args(const FTestClientOptionalInt16& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI16Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI16Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h new file mode 100644 index 00000000000..a1110d89138 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + FDeleteUniqueOptionI256Args() = default; + + FDeleteUniqueOptionI256Args(const FTestClientOptionalInt256& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI256Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI256Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h new file mode 100644 index 00000000000..2b6ceff829e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + FDeleteUniqueOptionI32Args() = default; + + FDeleteUniqueOptionI32Args(const FTestClientOptionalInt32& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI32Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI32Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h new file mode 100644 index 00000000000..b9314160677 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + FDeleteUniqueOptionI64Args() = default; + + FDeleteUniqueOptionI64Args(const FTestClientOptionalInt64& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI64Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI64Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h new file mode 100644 index 00000000000..ef9d577e5a5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + FDeleteUniqueOptionI8Args() = default; + + FDeleteUniqueOptionI8Args(const FTestClientOptionalInt8& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionI8Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionI8Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..9b404be0674 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + FDeleteUniqueOptionIdentityArgs() = default; + + FDeleteUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI) + : I(InI) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionIdentityArgs& Other) const + { + return I == Other.I; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionIdentityArgs, I); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h new file mode 100644 index 00000000000..4279f076882 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionString.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionString.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + FDeleteUniqueOptionStringArgs() = default; + + FDeleteUniqueOptionStringArgs(const FTestClientOptionalString& InS) + : S(InS) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionStringArgs& Other) const + { + return S == Other.S; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionStringArgs, S); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h new file mode 100644 index 00000000000..16ce9978cd5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + FDeleteUniqueOptionU128Args() = default; + + FDeleteUniqueOptionU128Args(const FTestClientOptionalUInt128& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU128Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU128Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h new file mode 100644 index 00000000000..55ef7665cd7 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + FDeleteUniqueOptionU16Args() = default; + + FDeleteUniqueOptionU16Args(const FTestClientOptionalUInt16& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU16Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU16Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h new file mode 100644 index 00000000000..f49e5d5831b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + FDeleteUniqueOptionU256Args() = default; + + FDeleteUniqueOptionU256Args(const FTestClientOptionalUInt256& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU256Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU256Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h new file mode 100644 index 00000000000..bb6dfd3ecad --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + FDeleteUniqueOptionU32Args() = default; + + FDeleteUniqueOptionU32Args(const FTestClientOptionalUInt32& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU32Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU32Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h new file mode 100644 index 00000000000..d66100b2c8d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + FDeleteUniqueOptionU64Args() = default; + + FDeleteUniqueOptionU64Args(const FTestClientOptionalUInt64& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU64Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU64Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h new file mode 100644 index 00000000000..748ffaa61ed --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h @@ -0,0 +1,54 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "DeleteUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + FDeleteUniqueOptionU8Args() = default; + + FDeleteUniqueOptionU8Args(const FTestClientOptionalUInt8& InN) + : N(InN) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionU8Args& Other) const + { + return N == Other.N; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionU8Args, N); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h new file mode 100644 index 00000000000..68175dfe8f3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h @@ -0,0 +1,55 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "DeleteUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for DeleteUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FDeleteUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + FDeleteUniqueOptionUuidArgs() = default; + + FDeleteUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU) + : U(InU) + {} + + + FORCEINLINE bool operator==(const FDeleteUniqueOptionUuidArgs& Other) const + { + return U == Other.U; + } + FORCEINLINE bool operator!=(const FDeleteUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FDeleteUniqueOptionUuidArgs, U); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UDeleteUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h new file mode 100644 index 00000000000..a99f57b001e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionBoolArgs() = default; + + FInsertUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..cadb3b70318 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionConnectionIdArgs() = default; + + FInsertUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h new file mode 100644 index 00000000000..23bea7a977d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI128Args() = default; + + FInsertUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h new file mode 100644 index 00000000000..45af3a85aa6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI16Args() = default; + + FInsertUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h new file mode 100644 index 00000000000..daccf84f015 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI256Args() = default; + + FInsertUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h new file mode 100644 index 00000000000..b1de7b24a64 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI32Args() = default; + + FInsertUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h new file mode 100644 index 00000000000..d4411896ce4 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI64Args() = default; + + FInsertUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h new file mode 100644 index 00000000000..1aa15e36ecc --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionI8Args() = default; + + FInsertUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..87fd450b97d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionIdentityArgs() = default; + + FInsertUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h new file mode 100644 index 00000000000..2a3d23f947e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionString.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionStringArgs() = default; + + FInsertUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h new file mode 100644 index 00000000000..f1f08bfdf07 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU128Args() = default; + + FInsertUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h new file mode 100644 index 00000000000..43a0e781ace --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU16Args() = default; + + FInsertUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h new file mode 100644 index 00000000000..3ffc606a1a7 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU256Args() = default; + + FInsertUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h new file mode 100644 index 00000000000..e4f9053524f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU32Args() = default; + + FInsertUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h new file mode 100644 index 00000000000..8d96a0870c3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU64Args() = default; + + FInsertUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h new file mode 100644 index 00000000000..b76efbae67b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "InsertUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionU8Args() = default; + + FInsertUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h new file mode 100644 index 00000000000..b5fe2976d3c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "InsertUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for InsertUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FInsertUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FInsertUniqueOptionUuidArgs() = default; + + FInsertUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FInsertUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FInsertUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FInsertUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UInsertUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h new file mode 100644 index 00000000000..6e869f92efb --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionBool.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionBool +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionBoolArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionBoolArgs() = default; + + FUpdateUniqueOptionBoolArgs(const FTestClientOptionalBool& InB, const int32& InData) + : B(InB), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionBoolArgs& Other) const + { + return B == Other.B && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionBoolArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionBoolArgs, B, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionBoolReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalBool B; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h new file mode 100644 index 00000000000..9020567a5a0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionConnectionId.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionConnectionId +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionConnectionIdArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionConnectionIdArgs() = default; + + FUpdateUniqueOptionConnectionIdArgs(const FTestClientOptionalConnectionId& InA, const int32& InData) + : A(InA), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionConnectionIdArgs& Other) const + { + return A == Other.A && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionConnectionIdArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionConnectionIdArgs, A, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionConnectionIdReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalConnectionId A; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h new file mode 100644 index 00000000000..6bfea671305 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionI128.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI128Args() = default; + + FUpdateUniqueOptionI128Args(const FTestClientOptionalInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h new file mode 100644 index 00000000000..2cea8b44941 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI16.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI16Args() = default; + + FUpdateUniqueOptionI16Args(const FTestClientOptionalInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h new file mode 100644 index 00000000000..5465fff3c86 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionI256.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI256Args() = default; + + FUpdateUniqueOptionI256Args(const FTestClientOptionalInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h new file mode 100644 index 00000000000..f44ffe1fa6b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI32.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI32Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI32Args() = default; + + FUpdateUniqueOptionI32Args(const FTestClientOptionalInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h new file mode 100644 index 00000000000..0e8c99c386a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI64.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI64Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI64Args() = default; + + FUpdateUniqueOptionI64Args(const FTestClientOptionalInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h new file mode 100644 index 00000000000..626d12b9cd6 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionI8.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionI8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionI8Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionI8Args() = default; + + FUpdateUniqueOptionI8Args(const FTestClientOptionalInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionI8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionI8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionI8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionI8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h new file mode 100644 index 00000000000..6360e31708e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionIdentity.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionIdentity +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionIdentityArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionIdentityArgs() = default; + + FUpdateUniqueOptionIdentityArgs(const FTestClientOptionalIdentity& InI, const int32& InData) + : I(InI), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionIdentityArgs& Other) const + { + return I == Other.I && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionIdentityArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionIdentityArgs, I, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionIdentityReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalIdentity I; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h new file mode 100644 index 00000000000..6a13f036f3e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionString.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionString.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionString +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionStringArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionStringArgs() = default; + + FUpdateUniqueOptionStringArgs(const FTestClientOptionalString& InS, const int32& InData) + : S(InS), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionStringArgs& Other) const + { + return S == Other.S && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionStringArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionStringArgs, S, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionStringReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalString S; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h new file mode 100644 index 00000000000..e9d3de50e66 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionU128.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU128 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU128Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU128Args() = default; + + FUpdateUniqueOptionU128Args(const FTestClientOptionalUInt128& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU128Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU128Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU128Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU128Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt128 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h new file mode 100644 index 00000000000..b3f89e58e7e --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU16.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU16 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU16Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU16Args() = default; + + FUpdateUniqueOptionU16Args(const FTestClientOptionalUInt16& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU16Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU16Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU16Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU16Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h new file mode 100644 index 00000000000..572cf21ae1a --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionU256.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU256 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU256Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU256Args() = default; + + FUpdateUniqueOptionU256Args(const FTestClientOptionalUInt256& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU256Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU256Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU256Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU256Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt256 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h new file mode 100644 index 00000000000..f8efa3d2052 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU32.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU32 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU32Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU32Args() = default; + + FUpdateUniqueOptionU32Args(const FTestClientOptionalUInt32& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU32Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU32Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU32Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU32Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h new file mode 100644 index 00000000000..d4b84c45f9b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU64.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU64 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU64Args +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU64Args() = default; + + FUpdateUniqueOptionU64Args(const FTestClientOptionalUInt64& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU64Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU64Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU64Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU64Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h new file mode 100644 index 00000000000..ea40e603648 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h @@ -0,0 +1,59 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "UpdateUniqueOptionU8.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionU8 +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionU8Args +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionU8Args() = default; + + FUpdateUniqueOptionU8Args(const FTestClientOptionalUInt8& InN, const int32& InData) + : N(InN), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionU8Args& Other) const + { + return N == Other.N && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionU8Args& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionU8Args, N, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionU8Reducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUInt8 N; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h new file mode 100644 index 00000000000..5ffa7a6b691 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h @@ -0,0 +1,60 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "ModuleBindings/ReducerBase.g.h" +#include "Types/Builtins.h" +#include "UpdateUniqueOptionUuid.g.generated.h" + +// Reducer arguments struct for UpdateUniqueOptionUuid +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUpdateUniqueOptionUuidArgs +{ + GENERATED_BODY() + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(BlueprintReadWrite, Category="SpacetimeDB") + int32 Data = 0; + + FUpdateUniqueOptionUuidArgs() = default; + + FUpdateUniqueOptionUuidArgs(const FTestClientOptionalUuid& InU, const int32& InData) + : U(InU), Data(InData) + {} + + + FORCEINLINE bool operator==(const FUpdateUniqueOptionUuidArgs& Other) const + { + return U == Other.U && Data == Other.Data; + } + FORCEINLINE bool operator!=(const FUpdateUniqueOptionUuidArgs& Other) const + { + return !(*this == Other); + } +}; + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_STRUCT(FUpdateUniqueOptionUuidArgs, U, Data); +} + +// Reducer class for internal dispatching +UCLASS(BlueprintType) +class TESTCLIENT_API UUpdateUniqueOptionUuidReducer : public UReducerBase +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + FTestClientOptionalUuid U; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + int32 Data = 0; + +}; + + diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h index b6c7c76ec36..24e247be240 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" @@ -11,11 +11,24 @@ #include "Connection/DbConnectionBuilder.h" #include "Connection/Subscription.h" #include "Kismet/BlueprintFunctionLibrary.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" #include "ModuleBindings/Optionals/TestClientOptionalEveryPrimitiveStruct.g.h" #include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" #include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" #include "ModuleBindings/Optionals/TestClientOptionalSimpleEnum.g.h" #include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" #include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" #include "ModuleBindings/Optionals/TestClientOptionalVecOptionalInt32.g.h" #include "ModuleBindings/ReducerBase.g.h" @@ -78,6 +91,23 @@ #include "ModuleBindings/Reducers/DeleteAllUniqueI64.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueI8.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/DeleteAllUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueString.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueU128.g.h" #include "ModuleBindings/Reducers/DeleteAllUniqueU16.g.h" @@ -141,6 +171,23 @@ #include "ModuleBindings/Reducers/DeleteUniqueI64.g.h" #include "ModuleBindings/Reducers/DeleteUniqueI8.g.h" #include "ModuleBindings/Reducers/DeleteUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/DeleteUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/DeleteUniqueString.g.h" #include "ModuleBindings/Reducers/DeleteUniqueU128.g.h" #include "ModuleBindings/Reducers/DeleteUniqueU16.g.h" @@ -233,6 +280,23 @@ #include "ModuleBindings/Reducers/InsertUniqueI64.g.h" #include "ModuleBindings/Reducers/InsertUniqueI8.g.h" #include "ModuleBindings/Reducers/InsertUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/InsertUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/InsertUniqueString.g.h" #include "ModuleBindings/Reducers/InsertUniqueU128.g.h" #include "ModuleBindings/Reducers/InsertUniqueU16.g.h" @@ -300,6 +364,23 @@ #include "ModuleBindings/Reducers/UpdateUniqueI64.g.h" #include "ModuleBindings/Reducers/UpdateUniqueI8.g.h" #include "ModuleBindings/Reducers/UpdateUniqueIdentity.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionBool.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionConnectionId.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI128.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI16.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI256.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI32.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI64.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionI8.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionIdentity.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionString.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU128.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU16.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU256.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU32.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU64.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionU8.g.h" +#include "ModuleBindings/Reducers/UpdateUniqueOptionUuid.g.h" #include "ModuleBindings/Reducers/UpdateUniqueString.g.h" #include "ModuleBindings/Reducers/UpdateUniqueU128.g.h" #include "ModuleBindings/Reducers/UpdateUniqueU16.g.h" @@ -391,6 +472,23 @@ #include "ModuleBindings/Types/UniqueI64Type.g.h" #include "ModuleBindings/Types/UniqueI8Type.g.h" #include "ModuleBindings/Types/UniqueIdentityType.g.h" +#include "ModuleBindings/Types/UniqueOptionBoolType.g.h" +#include "ModuleBindings/Types/UniqueOptionConnectionIdType.g.h" +#include "ModuleBindings/Types/UniqueOptionI128Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI16Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI256Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI32Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI64Type.g.h" +#include "ModuleBindings/Types/UniqueOptionI8Type.g.h" +#include "ModuleBindings/Types/UniqueOptionIdentityType.g.h" +#include "ModuleBindings/Types/UniqueOptionStringType.g.h" +#include "ModuleBindings/Types/UniqueOptionU128Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU16Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU256Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU32Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU64Type.g.h" +#include "ModuleBindings/Types/UniqueOptionU8Type.g.h" +#include "ModuleBindings/Types/UniqueOptionUuidType.g.h" #include "ModuleBindings/Types/UniqueStringType.g.h" #include "ModuleBindings/Types/UniqueU128Type.g.h" #include "ModuleBindings/Types/UniqueU16Type.g.h" @@ -512,6 +610,23 @@ class UUniqueI32Table; class UUniqueI64Table; class UUniqueI8Table; class UUniqueIdentityTable; +class UUniqueOptionBoolTable; +class UUniqueOptionConnectionIdTable; +class UUniqueOptionI128Table; +class UUniqueOptionI16Table; +class UUniqueOptionI256Table; +class UUniqueOptionI32Table; +class UUniqueOptionI64Table; +class UUniqueOptionI8Table; +class UUniqueOptionIdentityTable; +class UUniqueOptionStringTable; +class UUniqueOptionU128Table; +class UUniqueOptionU16Table; +class UUniqueOptionU256Table; +class UUniqueOptionU32Table; +class UUniqueOptionU64Table; +class UUniqueOptionU8Table; +class UUniqueOptionUuidTable; class UUniqueStringTable; class UUniqueU128Table; class UUniqueU16Table; @@ -674,6 +789,23 @@ enum class EReducerTag : int32 DeleteAllUniqueI64, DeleteAllUniqueI8, DeleteAllUniqueIdentity, + DeleteAllUniqueOptionBool, + DeleteAllUniqueOptionConnectionId, + DeleteAllUniqueOptionI128, + DeleteAllUniqueOptionI16, + DeleteAllUniqueOptionI256, + DeleteAllUniqueOptionI32, + DeleteAllUniqueOptionI64, + DeleteAllUniqueOptionI8, + DeleteAllUniqueOptionIdentity, + DeleteAllUniqueOptionString, + DeleteAllUniqueOptionU128, + DeleteAllUniqueOptionU16, + DeleteAllUniqueOptionU256, + DeleteAllUniqueOptionU32, + DeleteAllUniqueOptionU64, + DeleteAllUniqueOptionU8, + DeleteAllUniqueOptionUuid, DeleteAllUniqueString, DeleteAllUniqueU128, DeleteAllUniqueU16, @@ -737,6 +869,23 @@ enum class EReducerTag : int32 DeleteUniqueI64, DeleteUniqueI8, DeleteUniqueIdentity, + DeleteUniqueOptionBool, + DeleteUniqueOptionConnectionId, + DeleteUniqueOptionI128, + DeleteUniqueOptionI16, + DeleteUniqueOptionI256, + DeleteUniqueOptionI32, + DeleteUniqueOptionI64, + DeleteUniqueOptionI8, + DeleteUniqueOptionIdentity, + DeleteUniqueOptionString, + DeleteUniqueOptionU128, + DeleteUniqueOptionU16, + DeleteUniqueOptionU256, + DeleteUniqueOptionU32, + DeleteUniqueOptionU64, + DeleteUniqueOptionU8, + DeleteUniqueOptionUuid, DeleteUniqueString, DeleteUniqueU128, DeleteUniqueU16, @@ -829,6 +978,23 @@ enum class EReducerTag : int32 InsertUniqueI64, InsertUniqueI8, InsertUniqueIdentity, + InsertUniqueOptionBool, + InsertUniqueOptionConnectionId, + InsertUniqueOptionI128, + InsertUniqueOptionI16, + InsertUniqueOptionI256, + InsertUniqueOptionI32, + InsertUniqueOptionI64, + InsertUniqueOptionI8, + InsertUniqueOptionIdentity, + InsertUniqueOptionString, + InsertUniqueOptionU128, + InsertUniqueOptionU16, + InsertUniqueOptionU256, + InsertUniqueOptionU32, + InsertUniqueOptionU64, + InsertUniqueOptionU8, + InsertUniqueOptionUuid, InsertUniqueString, InsertUniqueU128, InsertUniqueU16, @@ -896,6 +1062,23 @@ enum class EReducerTag : int32 UpdateUniqueI64, UpdateUniqueI8, UpdateUniqueIdentity, + UpdateUniqueOptionBool, + UpdateUniqueOptionConnectionId, + UpdateUniqueOptionI128, + UpdateUniqueOptionI16, + UpdateUniqueOptionI256, + UpdateUniqueOptionI32, + UpdateUniqueOptionI64, + UpdateUniqueOptionI8, + UpdateUniqueOptionIdentity, + UpdateUniqueOptionString, + UpdateUniqueOptionU128, + UpdateUniqueOptionU16, + UpdateUniqueOptionU256, + UpdateUniqueOptionU32, + UpdateUniqueOptionU64, + UpdateUniqueOptionU8, + UpdateUniqueOptionUuid, UpdateUniqueString, UpdateUniqueU128, UpdateUniqueU16, @@ -1997,6 +2180,312 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FDeleteAllUniqueIdentityArgs(); } + static FReducer DeleteAllUniqueOptionBool(const FDeleteAllUniqueOptionBoolArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_bool"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionBool() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionBool); } + FORCEINLINE FDeleteAllUniqueOptionBoolArgs GetAsDeleteAllUniqueOptionBool() const + { + ensureMsgf(IsDeleteAllUniqueOptionBool(), TEXT("Reducer does not hold DeleteAllUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionBool!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionBoolArgs(); + } + + static FReducer DeleteAllUniqueOptionConnectionId(const FDeleteAllUniqueOptionConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_connection_id"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId); } + FORCEINLINE FDeleteAllUniqueOptionConnectionIdArgs GetAsDeleteAllUniqueOptionConnectionId() const + { + ensureMsgf(IsDeleteAllUniqueOptionConnectionId(), TEXT("Reducer does not hold DeleteAllUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionConnectionIdArgs(); + } + + static FReducer DeleteAllUniqueOptionI128(const FDeleteAllUniqueOptionI128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_128"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI128() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI128); } + FORCEINLINE FDeleteAllUniqueOptionI128Args GetAsDeleteAllUniqueOptionI128() const + { + ensureMsgf(IsDeleteAllUniqueOptionI128(), TEXT("Reducer does not hold DeleteAllUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI128!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI128Args(); + } + + static FReducer DeleteAllUniqueOptionI16(const FDeleteAllUniqueOptionI16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_16"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI16() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI16); } + FORCEINLINE FDeleteAllUniqueOptionI16Args GetAsDeleteAllUniqueOptionI16() const + { + ensureMsgf(IsDeleteAllUniqueOptionI16(), TEXT("Reducer does not hold DeleteAllUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI16!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI16Args(); + } + + static FReducer DeleteAllUniqueOptionI256(const FDeleteAllUniqueOptionI256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_256"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI256() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI256); } + FORCEINLINE FDeleteAllUniqueOptionI256Args GetAsDeleteAllUniqueOptionI256() const + { + ensureMsgf(IsDeleteAllUniqueOptionI256(), TEXT("Reducer does not hold DeleteAllUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI256!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI256Args(); + } + + static FReducer DeleteAllUniqueOptionI32(const FDeleteAllUniqueOptionI32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_32"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI32() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI32); } + FORCEINLINE FDeleteAllUniqueOptionI32Args GetAsDeleteAllUniqueOptionI32() const + { + ensureMsgf(IsDeleteAllUniqueOptionI32(), TEXT("Reducer does not hold DeleteAllUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI32!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI32Args(); + } + + static FReducer DeleteAllUniqueOptionI64(const FDeleteAllUniqueOptionI64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_64"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI64() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI64); } + FORCEINLINE FDeleteAllUniqueOptionI64Args GetAsDeleteAllUniqueOptionI64() const + { + ensureMsgf(IsDeleteAllUniqueOptionI64(), TEXT("Reducer does not hold DeleteAllUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI64!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI64Args(); + } + + static FReducer DeleteAllUniqueOptionI8(const FDeleteAllUniqueOptionI8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_i_8"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionI8() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionI8); } + FORCEINLINE FDeleteAllUniqueOptionI8Args GetAsDeleteAllUniqueOptionI8() const + { + ensureMsgf(IsDeleteAllUniqueOptionI8(), TEXT("Reducer does not hold DeleteAllUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionI8!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionI8Args(); + } + + static FReducer DeleteAllUniqueOptionIdentity(const FDeleteAllUniqueOptionIdentityArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionIdentity); } + FORCEINLINE FDeleteAllUniqueOptionIdentityArgs GetAsDeleteAllUniqueOptionIdentity() const + { + ensureMsgf(IsDeleteAllUniqueOptionIdentity(), TEXT("Reducer does not hold DeleteAllUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionIdentityArgs(); + } + + static FReducer DeleteAllUniqueOptionString(const FDeleteAllUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionString() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionString); } + FORCEINLINE FDeleteAllUniqueOptionStringArgs GetAsDeleteAllUniqueOptionString() const + { + ensureMsgf(IsDeleteAllUniqueOptionString(), TEXT("Reducer does not hold DeleteAllUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionString!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionStringArgs(); + } + + static FReducer DeleteAllUniqueOptionU128(const FDeleteAllUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU128() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU128); } + FORCEINLINE FDeleteAllUniqueOptionU128Args GetAsDeleteAllUniqueOptionU128() const + { + ensureMsgf(IsDeleteAllUniqueOptionU128(), TEXT("Reducer does not hold DeleteAllUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU128!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU128Args(); + } + + static FReducer DeleteAllUniqueOptionU16(const FDeleteAllUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU16() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU16); } + FORCEINLINE FDeleteAllUniqueOptionU16Args GetAsDeleteAllUniqueOptionU16() const + { + ensureMsgf(IsDeleteAllUniqueOptionU16(), TEXT("Reducer does not hold DeleteAllUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU16!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU16Args(); + } + + static FReducer DeleteAllUniqueOptionU256(const FDeleteAllUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU256() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU256); } + FORCEINLINE FDeleteAllUniqueOptionU256Args GetAsDeleteAllUniqueOptionU256() const + { + ensureMsgf(IsDeleteAllUniqueOptionU256(), TEXT("Reducer does not hold DeleteAllUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU256!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU256Args(); + } + + static FReducer DeleteAllUniqueOptionU32(const FDeleteAllUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU32() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU32); } + FORCEINLINE FDeleteAllUniqueOptionU32Args GetAsDeleteAllUniqueOptionU32() const + { + ensureMsgf(IsDeleteAllUniqueOptionU32(), TEXT("Reducer does not hold DeleteAllUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU32!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU32Args(); + } + + static FReducer DeleteAllUniqueOptionU64(const FDeleteAllUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU64() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU64); } + FORCEINLINE FDeleteAllUniqueOptionU64Args GetAsDeleteAllUniqueOptionU64() const + { + ensureMsgf(IsDeleteAllUniqueOptionU64(), TEXT("Reducer does not hold DeleteAllUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU64!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU64Args(); + } + + static FReducer DeleteAllUniqueOptionU8(const FDeleteAllUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionU8() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionU8); } + FORCEINLINE FDeleteAllUniqueOptionU8Args GetAsDeleteAllUniqueOptionU8() const + { + ensureMsgf(IsDeleteAllUniqueOptionU8(), TEXT("Reducer does not hold DeleteAllUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionU8!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionU8Args(); + } + + static FReducer DeleteAllUniqueOptionUuid(const FDeleteAllUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteAllUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_all_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteAllUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::DeleteAllUniqueOptionUuid); } + FORCEINLINE FDeleteAllUniqueOptionUuidArgs GetAsDeleteAllUniqueOptionUuid() const + { + ensureMsgf(IsDeleteAllUniqueOptionUuid(), TEXT("Reducer does not hold DeleteAllUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteAllUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FDeleteAllUniqueOptionUuidArgs(); + } + static FReducer DeleteAllUniqueString(const FDeleteAllUniqueStringArgs& Value) { FReducer Out; @@ -3131,220 +3620,526 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FDeleteUniqueIdentityArgs(); } - static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) + static FReducer DeleteUniqueOptionBool(const FDeleteUniqueOptionBoolArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueString); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_string"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_bool"); return Out; } - FORCEINLINE bool IsDeleteUniqueString() const { return Tag == static_cast(EReducerTag::DeleteUniqueString); } - FORCEINLINE FDeleteUniqueStringArgs GetAsDeleteUniqueString() const + FORCEINLINE bool IsDeleteUniqueOptionBool() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionBool); } + FORCEINLINE FDeleteUniqueOptionBoolArgs GetAsDeleteUniqueOptionBool() const { - ensureMsgf(IsDeleteUniqueString(), TEXT("Reducer does not hold DeleteUniqueString!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueString!")); - return TypedData ? TypedData->Value : FDeleteUniqueStringArgs(); + ensureMsgf(IsDeleteUniqueOptionBool(), TEXT("Reducer does not hold DeleteUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionBool!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionBoolArgs(); } - static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) + static FReducer DeleteUniqueOptionConnectionId(const FDeleteUniqueOptionConnectionIdArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU128); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_128"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_connection_id"); return Out; } - FORCEINLINE bool IsDeleteUniqueU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueU128); } - FORCEINLINE FDeleteUniqueU128Args GetAsDeleteUniqueU128() const + FORCEINLINE bool IsDeleteUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionConnectionId); } + FORCEINLINE FDeleteUniqueOptionConnectionIdArgs GetAsDeleteUniqueOptionConnectionId() const { - ensureMsgf(IsDeleteUniqueU128(), TEXT("Reducer does not hold DeleteUniqueU128!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU128!")); - return TypedData ? TypedData->Value : FDeleteUniqueU128Args(); + ensureMsgf(IsDeleteUniqueOptionConnectionId(), TEXT("Reducer does not hold DeleteUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionConnectionIdArgs(); } - static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) + static FReducer DeleteUniqueOptionI128(const FDeleteUniqueOptionI128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU16); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_16"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_128"); return Out; } - FORCEINLINE bool IsDeleteUniqueU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueU16); } - FORCEINLINE FDeleteUniqueU16Args GetAsDeleteUniqueU16() const + FORCEINLINE bool IsDeleteUniqueOptionI128() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI128); } + FORCEINLINE FDeleteUniqueOptionI128Args GetAsDeleteUniqueOptionI128() const { - ensureMsgf(IsDeleteUniqueU16(), TEXT("Reducer does not hold DeleteUniqueU16!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU16!")); - return TypedData ? TypedData->Value : FDeleteUniqueU16Args(); + ensureMsgf(IsDeleteUniqueOptionI128(), TEXT("Reducer does not hold DeleteUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI128!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI128Args(); } - static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) + static FReducer DeleteUniqueOptionI16(const FDeleteUniqueOptionI16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU256); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_256"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_16"); return Out; } - FORCEINLINE bool IsDeleteUniqueU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueU256); } - FORCEINLINE FDeleteUniqueU256Args GetAsDeleteUniqueU256() const + FORCEINLINE bool IsDeleteUniqueOptionI16() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI16); } + FORCEINLINE FDeleteUniqueOptionI16Args GetAsDeleteUniqueOptionI16() const { - ensureMsgf(IsDeleteUniqueU256(), TEXT("Reducer does not hold DeleteUniqueU256!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU256!")); - return TypedData ? TypedData->Value : FDeleteUniqueU256Args(); + ensureMsgf(IsDeleteUniqueOptionI16(), TEXT("Reducer does not hold DeleteUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI16!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI16Args(); } - static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) + static FReducer DeleteUniqueOptionI256(const FDeleteUniqueOptionI256Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU32); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_32"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_256"); return Out; } - FORCEINLINE bool IsDeleteUniqueU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueU32); } - FORCEINLINE FDeleteUniqueU32Args GetAsDeleteUniqueU32() const + FORCEINLINE bool IsDeleteUniqueOptionI256() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI256); } + FORCEINLINE FDeleteUniqueOptionI256Args GetAsDeleteUniqueOptionI256() const { - ensureMsgf(IsDeleteUniqueU32(), TEXT("Reducer does not hold DeleteUniqueU32!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU32!")); - return TypedData ? TypedData->Value : FDeleteUniqueU32Args(); + ensureMsgf(IsDeleteUniqueOptionI256(), TEXT("Reducer does not hold DeleteUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI256!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI256Args(); } - static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) + static FReducer DeleteUniqueOptionI32(const FDeleteUniqueOptionI32Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU64); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_64"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_32"); return Out; } - FORCEINLINE bool IsDeleteUniqueU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueU64); } - FORCEINLINE FDeleteUniqueU64Args GetAsDeleteUniqueU64() const + FORCEINLINE bool IsDeleteUniqueOptionI32() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI32); } + FORCEINLINE FDeleteUniqueOptionI32Args GetAsDeleteUniqueOptionI32() const { - ensureMsgf(IsDeleteUniqueU64(), TEXT("Reducer does not hold DeleteUniqueU64!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU64!")); - return TypedData ? TypedData->Value : FDeleteUniqueU64Args(); + ensureMsgf(IsDeleteUniqueOptionI32(), TEXT("Reducer does not hold DeleteUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI32!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI32Args(); } - static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) + static FReducer DeleteUniqueOptionI64(const FDeleteUniqueOptionI64Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueU8); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_u_8"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_64"); return Out; } - FORCEINLINE bool IsDeleteUniqueU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueU8); } - FORCEINLINE FDeleteUniqueU8Args GetAsDeleteUniqueU8() const + FORCEINLINE bool IsDeleteUniqueOptionI64() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI64); } + FORCEINLINE FDeleteUniqueOptionI64Args GetAsDeleteUniqueOptionI64() const { - ensureMsgf(IsDeleteUniqueU8(), TEXT("Reducer does not hold DeleteUniqueU8!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU8!")); - return TypedData ? TypedData->Value : FDeleteUniqueU8Args(); + ensureMsgf(IsDeleteUniqueOptionI64(), TEXT("Reducer does not hold DeleteUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI64!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI64Args(); } - static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) + static FReducer DeleteUniqueOptionI8(const FDeleteUniqueOptionI8Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::DeleteUniqueUuid); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("delete_unique_uuid"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_i_8"); return Out; } - FORCEINLINE bool IsDeleteUniqueUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueUuid); } - FORCEINLINE FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid() const + FORCEINLINE bool IsDeleteUniqueOptionI8() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionI8); } + FORCEINLINE FDeleteUniqueOptionI8Args GetAsDeleteUniqueOptionI8() const { - ensureMsgf(IsDeleteUniqueUuid(), TEXT("Reducer does not hold DeleteUniqueUuid!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueUuid!")); - return TypedData ? TypedData->Value : FDeleteUniqueUuidArgs(); + ensureMsgf(IsDeleteUniqueOptionI8(), TEXT("Reducer does not hold DeleteUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionI8!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionI8Args(); } - static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) + static FReducer DeleteUniqueOptionIdentity(const FDeleteUniqueOptionIdentityArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallTimestamp); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_timestamp"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_identity"); return Out; } - FORCEINLINE bool IsInsertCallTimestamp() const { return Tag == static_cast(EReducerTag::InsertCallTimestamp); } - FORCEINLINE FInsertCallTimestampArgs GetAsInsertCallTimestamp() const + FORCEINLINE bool IsDeleteUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionIdentity); } + FORCEINLINE FDeleteUniqueOptionIdentityArgs GetAsDeleteUniqueOptionIdentity() const { - ensureMsgf(IsInsertCallTimestamp(), TEXT("Reducer does not hold InsertCallTimestamp!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallTimestamp!")); - return TypedData ? TypedData->Value : FInsertCallTimestampArgs(); + ensureMsgf(IsDeleteUniqueOptionIdentity(), TEXT("Reducer does not hold DeleteUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionIdentityArgs(); } - static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) + static FReducer DeleteUniqueOptionString(const FDeleteUniqueOptionStringArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallUuidV4); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_uuid_v_4"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_string"); return Out; } - FORCEINLINE bool IsInsertCallUuidV4() const { return Tag == static_cast(EReducerTag::InsertCallUuidV4); } - FORCEINLINE FInsertCallUuidV4Args GetAsInsertCallUuidV4() const + FORCEINLINE bool IsDeleteUniqueOptionString() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionString); } + FORCEINLINE FDeleteUniqueOptionStringArgs GetAsDeleteUniqueOptionString() const { - ensureMsgf(IsInsertCallUuidV4(), TEXT("Reducer does not hold InsertCallUuidV4!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV4!")); - return TypedData ? TypedData->Value : FInsertCallUuidV4Args(); + ensureMsgf(IsDeleteUniqueOptionString(), TEXT("Reducer does not hold DeleteUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionString!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionStringArgs(); } - static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) + static FReducer DeleteUniqueOptionU128(const FDeleteUniqueOptionU128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallUuidV7); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_call_uuid_v_7"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_128"); return Out; } - FORCEINLINE bool IsInsertCallUuidV7() const { return Tag == static_cast(EReducerTag::InsertCallUuidV7); } - FORCEINLINE FInsertCallUuidV7Args GetAsInsertCallUuidV7() const + FORCEINLINE bool IsDeleteUniqueOptionU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU128); } + FORCEINLINE FDeleteUniqueOptionU128Args GetAsDeleteUniqueOptionU128() const { - ensureMsgf(IsInsertCallUuidV7(), TEXT("Reducer does not hold InsertCallUuidV7!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV7!")); - return TypedData ? TypedData->Value : FInsertCallUuidV7Args(); + ensureMsgf(IsDeleteUniqueOptionU128(), TEXT("Reducer does not hold DeleteUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU128!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU128Args(); } - static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) + static FReducer DeleteUniqueOptionU16(const FDeleteUniqueOptionU16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::InsertCallerOneConnectionId); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("insert_caller_one_connection_id"); + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_16"); return Out; } - FORCEINLINE bool IsInsertCallerOneConnectionId() const { return Tag == static_cast(EReducerTag::InsertCallerOneConnectionId); } - FORCEINLINE FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId() const + FORCEINLINE bool IsDeleteUniqueOptionU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU16); } + FORCEINLINE FDeleteUniqueOptionU16Args GetAsDeleteUniqueOptionU16() const { - ensureMsgf(IsInsertCallerOneConnectionId(), TEXT("Reducer does not hold InsertCallerOneConnectionId!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallerOneConnectionId!")); - return TypedData ? TypedData->Value : FInsertCallerOneConnectionIdArgs(); + ensureMsgf(IsDeleteUniqueOptionU16(), TEXT("Reducer does not hold DeleteUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU16!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU16Args(); + } + + static FReducer DeleteUniqueOptionU256(const FDeleteUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU256); } + FORCEINLINE FDeleteUniqueOptionU256Args GetAsDeleteUniqueOptionU256() const + { + ensureMsgf(IsDeleteUniqueOptionU256(), TEXT("Reducer does not hold DeleteUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU256!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU256Args(); + } + + static FReducer DeleteUniqueOptionU32(const FDeleteUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU32); } + FORCEINLINE FDeleteUniqueOptionU32Args GetAsDeleteUniqueOptionU32() const + { + ensureMsgf(IsDeleteUniqueOptionU32(), TEXT("Reducer does not hold DeleteUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU32!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU32Args(); + } + + static FReducer DeleteUniqueOptionU64(const FDeleteUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU64); } + FORCEINLINE FDeleteUniqueOptionU64Args GetAsDeleteUniqueOptionU64() const + { + ensureMsgf(IsDeleteUniqueOptionU64(), TEXT("Reducer does not hold DeleteUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU64!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU64Args(); + } + + static FReducer DeleteUniqueOptionU8(const FDeleteUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionU8); } + FORCEINLINE FDeleteUniqueOptionU8Args GetAsDeleteUniqueOptionU8() const + { + ensureMsgf(IsDeleteUniqueOptionU8(), TEXT("Reducer does not hold DeleteUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionU8!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionU8Args(); + } + + static FReducer DeleteUniqueOptionUuid(const FDeleteUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueOptionUuid); } + FORCEINLINE FDeleteUniqueOptionUuidArgs GetAsDeleteUniqueOptionUuid() const + { + ensureMsgf(IsDeleteUniqueOptionUuid(), TEXT("Reducer does not hold DeleteUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FDeleteUniqueOptionUuidArgs(); + } + + static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_string"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueString() const { return Tag == static_cast(EReducerTag::DeleteUniqueString); } + FORCEINLINE FDeleteUniqueStringArgs GetAsDeleteUniqueString() const + { + ensureMsgf(IsDeleteUniqueString(), TEXT("Reducer does not hold DeleteUniqueString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueString!")); + return TypedData ? TypedData->Value : FDeleteUniqueStringArgs(); + } + + static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_128"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU128() const { return Tag == static_cast(EReducerTag::DeleteUniqueU128); } + FORCEINLINE FDeleteUniqueU128Args GetAsDeleteUniqueU128() const + { + ensureMsgf(IsDeleteUniqueU128(), TEXT("Reducer does not hold DeleteUniqueU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU128!")); + return TypedData ? TypedData->Value : FDeleteUniqueU128Args(); + } + + static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_16"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU16() const { return Tag == static_cast(EReducerTag::DeleteUniqueU16); } + FORCEINLINE FDeleteUniqueU16Args GetAsDeleteUniqueU16() const + { + ensureMsgf(IsDeleteUniqueU16(), TEXT("Reducer does not hold DeleteUniqueU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU16!")); + return TypedData ? TypedData->Value : FDeleteUniqueU16Args(); + } + + static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_256"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU256() const { return Tag == static_cast(EReducerTag::DeleteUniqueU256); } + FORCEINLINE FDeleteUniqueU256Args GetAsDeleteUniqueU256() const + { + ensureMsgf(IsDeleteUniqueU256(), TEXT("Reducer does not hold DeleteUniqueU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU256!")); + return TypedData ? TypedData->Value : FDeleteUniqueU256Args(); + } + + static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_32"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU32() const { return Tag == static_cast(EReducerTag::DeleteUniqueU32); } + FORCEINLINE FDeleteUniqueU32Args GetAsDeleteUniqueU32() const + { + ensureMsgf(IsDeleteUniqueU32(), TEXT("Reducer does not hold DeleteUniqueU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU32!")); + return TypedData ? TypedData->Value : FDeleteUniqueU32Args(); + } + + static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_64"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU64() const { return Tag == static_cast(EReducerTag::DeleteUniqueU64); } + FORCEINLINE FDeleteUniqueU64Args GetAsDeleteUniqueU64() const + { + ensureMsgf(IsDeleteUniqueU64(), TEXT("Reducer does not hold DeleteUniqueU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU64!")); + return TypedData ? TypedData->Value : FDeleteUniqueU64Args(); + } + + static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_u_8"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueU8() const { return Tag == static_cast(EReducerTag::DeleteUniqueU8); } + FORCEINLINE FDeleteUniqueU8Args GetAsDeleteUniqueU8() const + { + ensureMsgf(IsDeleteUniqueU8(), TEXT("Reducer does not hold DeleteUniqueU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueU8!")); + return TypedData ? TypedData->Value : FDeleteUniqueU8Args(); + } + + static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::DeleteUniqueUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("delete_unique_uuid"); + return Out; + } + + FORCEINLINE bool IsDeleteUniqueUuid() const { return Tag == static_cast(EReducerTag::DeleteUniqueUuid); } + FORCEINLINE FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid() const + { + ensureMsgf(IsDeleteUniqueUuid(), TEXT("Reducer does not hold DeleteUniqueUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for DeleteUniqueUuid!")); + return TypedData ? TypedData->Value : FDeleteUniqueUuidArgs(); + } + + static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallTimestamp); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_timestamp"); + return Out; + } + + FORCEINLINE bool IsInsertCallTimestamp() const { return Tag == static_cast(EReducerTag::InsertCallTimestamp); } + FORCEINLINE FInsertCallTimestampArgs GetAsInsertCallTimestamp() const + { + ensureMsgf(IsInsertCallTimestamp(), TEXT("Reducer does not hold InsertCallTimestamp!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallTimestamp!")); + return TypedData ? TypedData->Value : FInsertCallTimestampArgs(); + } + + static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallUuidV4); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_uuid_v_4"); + return Out; + } + + FORCEINLINE bool IsInsertCallUuidV4() const { return Tag == static_cast(EReducerTag::InsertCallUuidV4); } + FORCEINLINE FInsertCallUuidV4Args GetAsInsertCallUuidV4() const + { + ensureMsgf(IsInsertCallUuidV4(), TEXT("Reducer does not hold InsertCallUuidV4!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV4!")); + return TypedData ? TypedData->Value : FInsertCallUuidV4Args(); + } + + static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallUuidV7); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_call_uuid_v_7"); + return Out; + } + + FORCEINLINE bool IsInsertCallUuidV7() const { return Tag == static_cast(EReducerTag::InsertCallUuidV7); } + FORCEINLINE FInsertCallUuidV7Args GetAsInsertCallUuidV7() const + { + ensureMsgf(IsInsertCallUuidV7(), TEXT("Reducer does not hold InsertCallUuidV7!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallUuidV7!")); + return TypedData ? TypedData->Value : FInsertCallUuidV7Args(); + } + + static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertCallerOneConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_caller_one_connection_id"); + return Out; + } + + FORCEINLINE bool IsInsertCallerOneConnectionId() const { return Tag == static_cast(EReducerTag::InsertCallerOneConnectionId); } + FORCEINLINE FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId() const + { + ensureMsgf(IsInsertCallerOneConnectionId(), TEXT("Reducer does not hold InsertCallerOneConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertCallerOneConnectionId!")); + return TypedData ? TypedData->Value : FInsertCallerOneConnectionIdArgs(); } static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) @@ -4787,6 +5582,312 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FInsertUniqueIdentityArgs(); } + static FReducer InsertUniqueOptionBool(const FInsertUniqueOptionBoolArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_bool"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionBool() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionBool); } + FORCEINLINE FInsertUniqueOptionBoolArgs GetAsInsertUniqueOptionBool() const + { + ensureMsgf(IsInsertUniqueOptionBool(), TEXT("Reducer does not hold InsertUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionBool!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionBoolArgs(); + } + + static FReducer InsertUniqueOptionConnectionId(const FInsertUniqueOptionConnectionIdArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_connection_id"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionConnectionId); } + FORCEINLINE FInsertUniqueOptionConnectionIdArgs GetAsInsertUniqueOptionConnectionId() const + { + ensureMsgf(IsInsertUniqueOptionConnectionId(), TEXT("Reducer does not hold InsertUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionConnectionIdArgs(); + } + + static FReducer InsertUniqueOptionI128(const FInsertUniqueOptionI128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_128"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI128() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI128); } + FORCEINLINE FInsertUniqueOptionI128Args GetAsInsertUniqueOptionI128() const + { + ensureMsgf(IsInsertUniqueOptionI128(), TEXT("Reducer does not hold InsertUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI128!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI128Args(); + } + + static FReducer InsertUniqueOptionI16(const FInsertUniqueOptionI16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_16"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI16() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI16); } + FORCEINLINE FInsertUniqueOptionI16Args GetAsInsertUniqueOptionI16() const + { + ensureMsgf(IsInsertUniqueOptionI16(), TEXT("Reducer does not hold InsertUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI16!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI16Args(); + } + + static FReducer InsertUniqueOptionI256(const FInsertUniqueOptionI256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_256"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI256() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI256); } + FORCEINLINE FInsertUniqueOptionI256Args GetAsInsertUniqueOptionI256() const + { + ensureMsgf(IsInsertUniqueOptionI256(), TEXT("Reducer does not hold InsertUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI256!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI256Args(); + } + + static FReducer InsertUniqueOptionI32(const FInsertUniqueOptionI32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_32"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI32() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI32); } + FORCEINLINE FInsertUniqueOptionI32Args GetAsInsertUniqueOptionI32() const + { + ensureMsgf(IsInsertUniqueOptionI32(), TEXT("Reducer does not hold InsertUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI32!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI32Args(); + } + + static FReducer InsertUniqueOptionI64(const FInsertUniqueOptionI64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_64"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI64() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI64); } + FORCEINLINE FInsertUniqueOptionI64Args GetAsInsertUniqueOptionI64() const + { + ensureMsgf(IsInsertUniqueOptionI64(), TEXT("Reducer does not hold InsertUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI64!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI64Args(); + } + + static FReducer InsertUniqueOptionI8(const FInsertUniqueOptionI8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_i_8"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionI8() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionI8); } + FORCEINLINE FInsertUniqueOptionI8Args GetAsInsertUniqueOptionI8() const + { + ensureMsgf(IsInsertUniqueOptionI8(), TEXT("Reducer does not hold InsertUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionI8!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionI8Args(); + } + + static FReducer InsertUniqueOptionIdentity(const FInsertUniqueOptionIdentityArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionIdentity); } + FORCEINLINE FInsertUniqueOptionIdentityArgs GetAsInsertUniqueOptionIdentity() const + { + ensureMsgf(IsInsertUniqueOptionIdentity(), TEXT("Reducer does not hold InsertUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionIdentityArgs(); + } + + static FReducer InsertUniqueOptionString(const FInsertUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionString() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionString); } + FORCEINLINE FInsertUniqueOptionStringArgs GetAsInsertUniqueOptionString() const + { + ensureMsgf(IsInsertUniqueOptionString(), TEXT("Reducer does not hold InsertUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionString!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionStringArgs(); + } + + static FReducer InsertUniqueOptionU128(const FInsertUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU128() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU128); } + FORCEINLINE FInsertUniqueOptionU128Args GetAsInsertUniqueOptionU128() const + { + ensureMsgf(IsInsertUniqueOptionU128(), TEXT("Reducer does not hold InsertUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU128!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU128Args(); + } + + static FReducer InsertUniqueOptionU16(const FInsertUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU16() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU16); } + FORCEINLINE FInsertUniqueOptionU16Args GetAsInsertUniqueOptionU16() const + { + ensureMsgf(IsInsertUniqueOptionU16(), TEXT("Reducer does not hold InsertUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU16!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU16Args(); + } + + static FReducer InsertUniqueOptionU256(const FInsertUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU256() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU256); } + FORCEINLINE FInsertUniqueOptionU256Args GetAsInsertUniqueOptionU256() const + { + ensureMsgf(IsInsertUniqueOptionU256(), TEXT("Reducer does not hold InsertUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU256!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU256Args(); + } + + static FReducer InsertUniqueOptionU32(const FInsertUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU32() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU32); } + FORCEINLINE FInsertUniqueOptionU32Args GetAsInsertUniqueOptionU32() const + { + ensureMsgf(IsInsertUniqueOptionU32(), TEXT("Reducer does not hold InsertUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU32!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU32Args(); + } + + static FReducer InsertUniqueOptionU64(const FInsertUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU64() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU64); } + FORCEINLINE FInsertUniqueOptionU64Args GetAsInsertUniqueOptionU64() const + { + ensureMsgf(IsInsertUniqueOptionU64(), TEXT("Reducer does not hold InsertUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU64!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU64Args(); + } + + static FReducer InsertUniqueOptionU8(const FInsertUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionU8() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionU8); } + FORCEINLINE FInsertUniqueOptionU8Args GetAsInsertUniqueOptionU8() const + { + ensureMsgf(IsInsertUniqueOptionU8(), TEXT("Reducer does not hold InsertUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionU8!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionU8Args(); + } + + static FReducer InsertUniqueOptionUuid(const FInsertUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::InsertUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("insert_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsInsertUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::InsertUniqueOptionUuid); } + FORCEINLINE FInsertUniqueOptionUuidArgs GetAsInsertUniqueOptionUuid() const + { + ensureMsgf(IsInsertUniqueOptionUuid(), TEXT("Reducer does not hold InsertUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for InsertUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FInsertUniqueOptionUuidArgs(); + } + static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { FReducer Out; @@ -5993,191 +7094,497 @@ struct TESTCLIENT_API FReducer return TypedData ? TypedData->Value : FUpdateUniqueIdentityArgs(); } - static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) + static FReducer UpdateUniqueOptionBool(const FUpdateUniqueOptionBoolArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueString); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_string"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionBool); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_bool"); return Out; } - FORCEINLINE bool IsUpdateUniqueString() const { return Tag == static_cast(EReducerTag::UpdateUniqueString); } - FORCEINLINE FUpdateUniqueStringArgs GetAsUpdateUniqueString() const + FORCEINLINE bool IsUpdateUniqueOptionBool() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionBool); } + FORCEINLINE FUpdateUniqueOptionBoolArgs GetAsUpdateUniqueOptionBool() const { - ensureMsgf(IsUpdateUniqueString(), TEXT("Reducer does not hold UpdateUniqueString!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueString!")); - return TypedData ? TypedData->Value : FUpdateUniqueStringArgs(); + ensureMsgf(IsUpdateUniqueOptionBool(), TEXT("Reducer does not hold UpdateUniqueOptionBool!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionBool!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionBoolArgs(); } - static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) + static FReducer UpdateUniqueOptionConnectionId(const FUpdateUniqueOptionConnectionIdArgs& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU128); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_128"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionConnectionId); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_connection_id"); return Out; } - FORCEINLINE bool IsUpdateUniqueU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueU128); } - FORCEINLINE FUpdateUniqueU128Args GetAsUpdateUniqueU128() const + FORCEINLINE bool IsUpdateUniqueOptionConnectionId() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionConnectionId); } + FORCEINLINE FUpdateUniqueOptionConnectionIdArgs GetAsUpdateUniqueOptionConnectionId() const { - ensureMsgf(IsUpdateUniqueU128(), TEXT("Reducer does not hold UpdateUniqueU128!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU128!")); - return TypedData ? TypedData->Value : FUpdateUniqueU128Args(); + ensureMsgf(IsUpdateUniqueOptionConnectionId(), TEXT("Reducer does not hold UpdateUniqueOptionConnectionId!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionConnectionId!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionConnectionIdArgs(); } - static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) + static FReducer UpdateUniqueOptionI128(const FUpdateUniqueOptionI128Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU16); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_16"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_128"); return Out; } - FORCEINLINE bool IsUpdateUniqueU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueU16); } - FORCEINLINE FUpdateUniqueU16Args GetAsUpdateUniqueU16() const + FORCEINLINE bool IsUpdateUniqueOptionI128() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI128); } + FORCEINLINE FUpdateUniqueOptionI128Args GetAsUpdateUniqueOptionI128() const { - ensureMsgf(IsUpdateUniqueU16(), TEXT("Reducer does not hold UpdateUniqueU16!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU16!")); - return TypedData ? TypedData->Value : FUpdateUniqueU16Args(); + ensureMsgf(IsUpdateUniqueOptionI128(), TEXT("Reducer does not hold UpdateUniqueOptionI128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI128!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI128Args(); } - static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) + static FReducer UpdateUniqueOptionI16(const FUpdateUniqueOptionI16Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU256); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_256"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_16"); return Out; } - FORCEINLINE bool IsUpdateUniqueU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueU256); } - FORCEINLINE FUpdateUniqueU256Args GetAsUpdateUniqueU256() const + FORCEINLINE bool IsUpdateUniqueOptionI16() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI16); } + FORCEINLINE FUpdateUniqueOptionI16Args GetAsUpdateUniqueOptionI16() const { - ensureMsgf(IsUpdateUniqueU256(), TEXT("Reducer does not hold UpdateUniqueU256!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU256!")); - return TypedData ? TypedData->Value : FUpdateUniqueU256Args(); + ensureMsgf(IsUpdateUniqueOptionI16(), TEXT("Reducer does not hold UpdateUniqueOptionI16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI16!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI16Args(); } - static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) + static FReducer UpdateUniqueOptionI256(const FUpdateUniqueOptionI256Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU32); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_32"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_256"); return Out; } - FORCEINLINE bool IsUpdateUniqueU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueU32); } - FORCEINLINE FUpdateUniqueU32Args GetAsUpdateUniqueU32() const + FORCEINLINE bool IsUpdateUniqueOptionI256() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI256); } + FORCEINLINE FUpdateUniqueOptionI256Args GetAsUpdateUniqueOptionI256() const { - ensureMsgf(IsUpdateUniqueU32(), TEXT("Reducer does not hold UpdateUniqueU32!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU32!")); - return TypedData ? TypedData->Value : FUpdateUniqueU32Args(); + ensureMsgf(IsUpdateUniqueOptionI256(), TEXT("Reducer does not hold UpdateUniqueOptionI256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI256!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI256Args(); } - static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) + static FReducer UpdateUniqueOptionI32(const FUpdateUniqueOptionI32Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU64); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_64"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_32"); return Out; } - FORCEINLINE bool IsUpdateUniqueU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueU64); } - FORCEINLINE FUpdateUniqueU64Args GetAsUpdateUniqueU64() const + FORCEINLINE bool IsUpdateUniqueOptionI32() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI32); } + FORCEINLINE FUpdateUniqueOptionI32Args GetAsUpdateUniqueOptionI32() const { - ensureMsgf(IsUpdateUniqueU64(), TEXT("Reducer does not hold UpdateUniqueU64!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU64!")); - return TypedData ? TypedData->Value : FUpdateUniqueU64Args(); + ensureMsgf(IsUpdateUniqueOptionI32(), TEXT("Reducer does not hold UpdateUniqueOptionI32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI32!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI32Args(); } - static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) + static FReducer UpdateUniqueOptionI64(const FUpdateUniqueOptionI64Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueU8); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_u_8"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_64"); return Out; } - FORCEINLINE bool IsUpdateUniqueU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueU8); } - FORCEINLINE FUpdateUniqueU8Args GetAsUpdateUniqueU8() const + FORCEINLINE bool IsUpdateUniqueOptionI64() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI64); } + FORCEINLINE FUpdateUniqueOptionI64Args GetAsUpdateUniqueOptionI64() const { - ensureMsgf(IsUpdateUniqueU8(), TEXT("Reducer does not hold UpdateUniqueU8!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU8!")); - return TypedData ? TypedData->Value : FUpdateUniqueU8Args(); + ensureMsgf(IsUpdateUniqueOptionI64(), TEXT("Reducer does not hold UpdateUniqueOptionI64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI64!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI64Args(); } - static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) + static FReducer UpdateUniqueOptionI8(const FUpdateUniqueOptionI8Args& Value) { FReducer Out; - Out.Tag = static_cast(EReducerTag::UpdateUniqueUuid); - Out.Data = MakeShared>(Value); - Out.ReducerName = TEXT("update_unique_uuid"); + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionI8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_i_8"); return Out; } - FORCEINLINE bool IsUpdateUniqueUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueUuid); } - FORCEINLINE FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid() const + FORCEINLINE bool IsUpdateUniqueOptionI8() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionI8); } + FORCEINLINE FUpdateUniqueOptionI8Args GetAsUpdateUniqueOptionI8() const { - ensureMsgf(IsUpdateUniqueUuid(), TEXT("Reducer does not hold UpdateUniqueUuid!")); - const auto* TypedData = static_cast*>(Data.Get()); - ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueUuid!")); - return TypedData ? TypedData->Value : FUpdateUniqueUuidArgs(); + ensureMsgf(IsUpdateUniqueOptionI8(), TEXT("Reducer does not hold UpdateUniqueOptionI8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionI8!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionI8Args(); } - FORCEINLINE bool operator==(const FReducer& Other) const + static FReducer UpdateUniqueOptionIdentity(const FUpdateUniqueOptionIdentityArgs& Value) { - if (Tag != Other.Tag || ReducerId != Other.ReducerId || RequestId != Other.RequestId || ReducerName != Other.ReducerName) return false; - switch (Tag) - { - case static_cast(EReducerTag::DeleteAllOneBool): - return GetAsDeleteAllOneBool() == Other.GetAsDeleteAllOneBool(); - case static_cast(EReducerTag::DeleteAllOneByteStruct): - return GetAsDeleteAllOneByteStruct() == Other.GetAsDeleteAllOneByteStruct(); - case static_cast(EReducerTag::DeleteAllOneEnumWithPayload): - return GetAsDeleteAllOneEnumWithPayload() == Other.GetAsDeleteAllOneEnumWithPayload(); - case static_cast(EReducerTag::DeleteAllOneEveryPrimitiveStruct): - return GetAsDeleteAllOneEveryPrimitiveStruct() == Other.GetAsDeleteAllOneEveryPrimitiveStruct(); - case static_cast(EReducerTag::DeleteAllOneEveryVecStruct): - return GetAsDeleteAllOneEveryVecStruct() == Other.GetAsDeleteAllOneEveryVecStruct(); - case static_cast(EReducerTag::DeleteAllOneF32): - return GetAsDeleteAllOneF32() == Other.GetAsDeleteAllOneF32(); - case static_cast(EReducerTag::DeleteAllOneF64): - return GetAsDeleteAllOneF64() == Other.GetAsDeleteAllOneF64(); - case static_cast(EReducerTag::DeleteAllOneI128): - return GetAsDeleteAllOneI128() == Other.GetAsDeleteAllOneI128(); - case static_cast(EReducerTag::DeleteAllOneI16): - return GetAsDeleteAllOneI16() == Other.GetAsDeleteAllOneI16(); - case static_cast(EReducerTag::DeleteAllOneI256): - return GetAsDeleteAllOneI256() == Other.GetAsDeleteAllOneI256(); - case static_cast(EReducerTag::DeleteAllOneI32): - return GetAsDeleteAllOneI32() == Other.GetAsDeleteAllOneI32(); - case static_cast(EReducerTag::DeleteAllOneI64): - return GetAsDeleteAllOneI64() == Other.GetAsDeleteAllOneI64(); - case static_cast(EReducerTag::DeleteAllOneI8): - return GetAsDeleteAllOneI8() == Other.GetAsDeleteAllOneI8(); - case static_cast(EReducerTag::DeleteAllOneIdentity): - return GetAsDeleteAllOneIdentity() == Other.GetAsDeleteAllOneIdentity(); - case static_cast(EReducerTag::DeleteAllOneSimpleEnum): - return GetAsDeleteAllOneSimpleEnum() == Other.GetAsDeleteAllOneSimpleEnum(); - case static_cast(EReducerTag::DeleteAllOneString): - return GetAsDeleteAllOneString() == Other.GetAsDeleteAllOneString(); - case static_cast(EReducerTag::DeleteAllOneTimestamp): - return GetAsDeleteAllOneTimestamp() == Other.GetAsDeleteAllOneTimestamp(); - case static_cast(EReducerTag::DeleteAllOneU128): - return GetAsDeleteAllOneU128() == Other.GetAsDeleteAllOneU128(); + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionIdentity); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_identity"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionIdentity() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionIdentity); } + FORCEINLINE FUpdateUniqueOptionIdentityArgs GetAsUpdateUniqueOptionIdentity() const + { + ensureMsgf(IsUpdateUniqueOptionIdentity(), TEXT("Reducer does not hold UpdateUniqueOptionIdentity!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionIdentity!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionIdentityArgs(); + } + + static FReducer UpdateUniqueOptionString(const FUpdateUniqueOptionStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_string"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionString() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionString); } + FORCEINLINE FUpdateUniqueOptionStringArgs GetAsUpdateUniqueOptionString() const + { + ensureMsgf(IsUpdateUniqueOptionString(), TEXT("Reducer does not hold UpdateUniqueOptionString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionString!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionStringArgs(); + } + + static FReducer UpdateUniqueOptionU128(const FUpdateUniqueOptionU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_128"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU128); } + FORCEINLINE FUpdateUniqueOptionU128Args GetAsUpdateUniqueOptionU128() const + { + ensureMsgf(IsUpdateUniqueOptionU128(), TEXT("Reducer does not hold UpdateUniqueOptionU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU128!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU128Args(); + } + + static FReducer UpdateUniqueOptionU16(const FUpdateUniqueOptionU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_16"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU16); } + FORCEINLINE FUpdateUniqueOptionU16Args GetAsUpdateUniqueOptionU16() const + { + ensureMsgf(IsUpdateUniqueOptionU16(), TEXT("Reducer does not hold UpdateUniqueOptionU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU16!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU16Args(); + } + + static FReducer UpdateUniqueOptionU256(const FUpdateUniqueOptionU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_256"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU256); } + FORCEINLINE FUpdateUniqueOptionU256Args GetAsUpdateUniqueOptionU256() const + { + ensureMsgf(IsUpdateUniqueOptionU256(), TEXT("Reducer does not hold UpdateUniqueOptionU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU256!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU256Args(); + } + + static FReducer UpdateUniqueOptionU32(const FUpdateUniqueOptionU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_32"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU32); } + FORCEINLINE FUpdateUniqueOptionU32Args GetAsUpdateUniqueOptionU32() const + { + ensureMsgf(IsUpdateUniqueOptionU32(), TEXT("Reducer does not hold UpdateUniqueOptionU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU32!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU32Args(); + } + + static FReducer UpdateUniqueOptionU64(const FUpdateUniqueOptionU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_64"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU64); } + FORCEINLINE FUpdateUniqueOptionU64Args GetAsUpdateUniqueOptionU64() const + { + ensureMsgf(IsUpdateUniqueOptionU64(), TEXT("Reducer does not hold UpdateUniqueOptionU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU64!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU64Args(); + } + + static FReducer UpdateUniqueOptionU8(const FUpdateUniqueOptionU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_u_8"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionU8); } + FORCEINLINE FUpdateUniqueOptionU8Args GetAsUpdateUniqueOptionU8() const + { + ensureMsgf(IsUpdateUniqueOptionU8(), TEXT("Reducer does not hold UpdateUniqueOptionU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionU8!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionU8Args(); + } + + static FReducer UpdateUniqueOptionUuid(const FUpdateUniqueOptionUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueOptionUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_option_uuid"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueOptionUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueOptionUuid); } + FORCEINLINE FUpdateUniqueOptionUuidArgs GetAsUpdateUniqueOptionUuid() const + { + ensureMsgf(IsUpdateUniqueOptionUuid(), TEXT("Reducer does not hold UpdateUniqueOptionUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueOptionUuid!")); + return TypedData ? TypedData->Value : FUpdateUniqueOptionUuidArgs(); + } + + static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueString); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_string"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueString() const { return Tag == static_cast(EReducerTag::UpdateUniqueString); } + FORCEINLINE FUpdateUniqueStringArgs GetAsUpdateUniqueString() const + { + ensureMsgf(IsUpdateUniqueString(), TEXT("Reducer does not hold UpdateUniqueString!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueString!")); + return TypedData ? TypedData->Value : FUpdateUniqueStringArgs(); + } + + static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU128); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_128"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU128() const { return Tag == static_cast(EReducerTag::UpdateUniqueU128); } + FORCEINLINE FUpdateUniqueU128Args GetAsUpdateUniqueU128() const + { + ensureMsgf(IsUpdateUniqueU128(), TEXT("Reducer does not hold UpdateUniqueU128!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU128!")); + return TypedData ? TypedData->Value : FUpdateUniqueU128Args(); + } + + static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU16); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_16"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU16() const { return Tag == static_cast(EReducerTag::UpdateUniqueU16); } + FORCEINLINE FUpdateUniqueU16Args GetAsUpdateUniqueU16() const + { + ensureMsgf(IsUpdateUniqueU16(), TEXT("Reducer does not hold UpdateUniqueU16!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU16!")); + return TypedData ? TypedData->Value : FUpdateUniqueU16Args(); + } + + static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU256); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_256"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU256() const { return Tag == static_cast(EReducerTag::UpdateUniqueU256); } + FORCEINLINE FUpdateUniqueU256Args GetAsUpdateUniqueU256() const + { + ensureMsgf(IsUpdateUniqueU256(), TEXT("Reducer does not hold UpdateUniqueU256!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU256!")); + return TypedData ? TypedData->Value : FUpdateUniqueU256Args(); + } + + static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU32); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_32"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU32() const { return Tag == static_cast(EReducerTag::UpdateUniqueU32); } + FORCEINLINE FUpdateUniqueU32Args GetAsUpdateUniqueU32() const + { + ensureMsgf(IsUpdateUniqueU32(), TEXT("Reducer does not hold UpdateUniqueU32!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU32!")); + return TypedData ? TypedData->Value : FUpdateUniqueU32Args(); + } + + static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU64); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_64"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU64() const { return Tag == static_cast(EReducerTag::UpdateUniqueU64); } + FORCEINLINE FUpdateUniqueU64Args GetAsUpdateUniqueU64() const + { + ensureMsgf(IsUpdateUniqueU64(), TEXT("Reducer does not hold UpdateUniqueU64!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU64!")); + return TypedData ? TypedData->Value : FUpdateUniqueU64Args(); + } + + static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueU8); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_u_8"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueU8() const { return Tag == static_cast(EReducerTag::UpdateUniqueU8); } + FORCEINLINE FUpdateUniqueU8Args GetAsUpdateUniqueU8() const + { + ensureMsgf(IsUpdateUniqueU8(), TEXT("Reducer does not hold UpdateUniqueU8!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueU8!")); + return TypedData ? TypedData->Value : FUpdateUniqueU8Args(); + } + + static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) + { + FReducer Out; + Out.Tag = static_cast(EReducerTag::UpdateUniqueUuid); + Out.Data = MakeShared>(Value); + Out.ReducerName = TEXT("update_unique_uuid"); + return Out; + } + + FORCEINLINE bool IsUpdateUniqueUuid() const { return Tag == static_cast(EReducerTag::UpdateUniqueUuid); } + FORCEINLINE FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid() const + { + ensureMsgf(IsUpdateUniqueUuid(), TEXT("Reducer does not hold UpdateUniqueUuid!")); + const auto* TypedData = static_cast*>(Data.Get()); + ensureMsgf(TypedData != nullptr, TEXT("Reducer payload is missing or has the wrong type for UpdateUniqueUuid!")); + return TypedData ? TypedData->Value : FUpdateUniqueUuidArgs(); + } + + FORCEINLINE bool operator==(const FReducer& Other) const + { + if (Tag != Other.Tag || ReducerId != Other.ReducerId || RequestId != Other.RequestId || ReducerName != Other.ReducerName) return false; + switch (Tag) + { + case static_cast(EReducerTag::DeleteAllOneBool): + return GetAsDeleteAllOneBool() == Other.GetAsDeleteAllOneBool(); + case static_cast(EReducerTag::DeleteAllOneByteStruct): + return GetAsDeleteAllOneByteStruct() == Other.GetAsDeleteAllOneByteStruct(); + case static_cast(EReducerTag::DeleteAllOneEnumWithPayload): + return GetAsDeleteAllOneEnumWithPayload() == Other.GetAsDeleteAllOneEnumWithPayload(); + case static_cast(EReducerTag::DeleteAllOneEveryPrimitiveStruct): + return GetAsDeleteAllOneEveryPrimitiveStruct() == Other.GetAsDeleteAllOneEveryPrimitiveStruct(); + case static_cast(EReducerTag::DeleteAllOneEveryVecStruct): + return GetAsDeleteAllOneEveryVecStruct() == Other.GetAsDeleteAllOneEveryVecStruct(); + case static_cast(EReducerTag::DeleteAllOneF32): + return GetAsDeleteAllOneF32() == Other.GetAsDeleteAllOneF32(); + case static_cast(EReducerTag::DeleteAllOneF64): + return GetAsDeleteAllOneF64() == Other.GetAsDeleteAllOneF64(); + case static_cast(EReducerTag::DeleteAllOneI128): + return GetAsDeleteAllOneI128() == Other.GetAsDeleteAllOneI128(); + case static_cast(EReducerTag::DeleteAllOneI16): + return GetAsDeleteAllOneI16() == Other.GetAsDeleteAllOneI16(); + case static_cast(EReducerTag::DeleteAllOneI256): + return GetAsDeleteAllOneI256() == Other.GetAsDeleteAllOneI256(); + case static_cast(EReducerTag::DeleteAllOneI32): + return GetAsDeleteAllOneI32() == Other.GetAsDeleteAllOneI32(); + case static_cast(EReducerTag::DeleteAllOneI64): + return GetAsDeleteAllOneI64() == Other.GetAsDeleteAllOneI64(); + case static_cast(EReducerTag::DeleteAllOneI8): + return GetAsDeleteAllOneI8() == Other.GetAsDeleteAllOneI8(); + case static_cast(EReducerTag::DeleteAllOneIdentity): + return GetAsDeleteAllOneIdentity() == Other.GetAsDeleteAllOneIdentity(); + case static_cast(EReducerTag::DeleteAllOneSimpleEnum): + return GetAsDeleteAllOneSimpleEnum() == Other.GetAsDeleteAllOneSimpleEnum(); + case static_cast(EReducerTag::DeleteAllOneString): + return GetAsDeleteAllOneString() == Other.GetAsDeleteAllOneString(); + case static_cast(EReducerTag::DeleteAllOneTimestamp): + return GetAsDeleteAllOneTimestamp() == Other.GetAsDeleteAllOneTimestamp(); + case static_cast(EReducerTag::DeleteAllOneU128): + return GetAsDeleteAllOneU128() == Other.GetAsDeleteAllOneU128(); case static_cast(EReducerTag::DeleteAllOneU16): return GetAsDeleteAllOneU16() == Other.GetAsDeleteAllOneU16(); case static_cast(EReducerTag::DeleteAllOneU256): @@ -6260,6 +7667,40 @@ struct TESTCLIENT_API FReducer return GetAsDeleteAllUniqueI8() == Other.GetAsDeleteAllUniqueI8(); case static_cast(EReducerTag::DeleteAllUniqueIdentity): return GetAsDeleteAllUniqueIdentity() == Other.GetAsDeleteAllUniqueIdentity(); + case static_cast(EReducerTag::DeleteAllUniqueOptionBool): + return GetAsDeleteAllUniqueOptionBool() == Other.GetAsDeleteAllUniqueOptionBool(); + case static_cast(EReducerTag::DeleteAllUniqueOptionConnectionId): + return GetAsDeleteAllUniqueOptionConnectionId() == Other.GetAsDeleteAllUniqueOptionConnectionId(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI128): + return GetAsDeleteAllUniqueOptionI128() == Other.GetAsDeleteAllUniqueOptionI128(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI16): + return GetAsDeleteAllUniqueOptionI16() == Other.GetAsDeleteAllUniqueOptionI16(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI256): + return GetAsDeleteAllUniqueOptionI256() == Other.GetAsDeleteAllUniqueOptionI256(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI32): + return GetAsDeleteAllUniqueOptionI32() == Other.GetAsDeleteAllUniqueOptionI32(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI64): + return GetAsDeleteAllUniqueOptionI64() == Other.GetAsDeleteAllUniqueOptionI64(); + case static_cast(EReducerTag::DeleteAllUniqueOptionI8): + return GetAsDeleteAllUniqueOptionI8() == Other.GetAsDeleteAllUniqueOptionI8(); + case static_cast(EReducerTag::DeleteAllUniqueOptionIdentity): + return GetAsDeleteAllUniqueOptionIdentity() == Other.GetAsDeleteAllUniqueOptionIdentity(); + case static_cast(EReducerTag::DeleteAllUniqueOptionString): + return GetAsDeleteAllUniqueOptionString() == Other.GetAsDeleteAllUniqueOptionString(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU128): + return GetAsDeleteAllUniqueOptionU128() == Other.GetAsDeleteAllUniqueOptionU128(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU16): + return GetAsDeleteAllUniqueOptionU16() == Other.GetAsDeleteAllUniqueOptionU16(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU256): + return GetAsDeleteAllUniqueOptionU256() == Other.GetAsDeleteAllUniqueOptionU256(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU32): + return GetAsDeleteAllUniqueOptionU32() == Other.GetAsDeleteAllUniqueOptionU32(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU64): + return GetAsDeleteAllUniqueOptionU64() == Other.GetAsDeleteAllUniqueOptionU64(); + case static_cast(EReducerTag::DeleteAllUniqueOptionU8): + return GetAsDeleteAllUniqueOptionU8() == Other.GetAsDeleteAllUniqueOptionU8(); + case static_cast(EReducerTag::DeleteAllUniqueOptionUuid): + return GetAsDeleteAllUniqueOptionUuid() == Other.GetAsDeleteAllUniqueOptionUuid(); case static_cast(EReducerTag::DeleteAllUniqueString): return GetAsDeleteAllUniqueString() == Other.GetAsDeleteAllUniqueString(); case static_cast(EReducerTag::DeleteAllUniqueU128): @@ -6386,6 +7827,40 @@ struct TESTCLIENT_API FReducer return GetAsDeleteUniqueI8() == Other.GetAsDeleteUniqueI8(); case static_cast(EReducerTag::DeleteUniqueIdentity): return GetAsDeleteUniqueIdentity() == Other.GetAsDeleteUniqueIdentity(); + case static_cast(EReducerTag::DeleteUniqueOptionBool): + return GetAsDeleteUniqueOptionBool() == Other.GetAsDeleteUniqueOptionBool(); + case static_cast(EReducerTag::DeleteUniqueOptionConnectionId): + return GetAsDeleteUniqueOptionConnectionId() == Other.GetAsDeleteUniqueOptionConnectionId(); + case static_cast(EReducerTag::DeleteUniqueOptionI128): + return GetAsDeleteUniqueOptionI128() == Other.GetAsDeleteUniqueOptionI128(); + case static_cast(EReducerTag::DeleteUniqueOptionI16): + return GetAsDeleteUniqueOptionI16() == Other.GetAsDeleteUniqueOptionI16(); + case static_cast(EReducerTag::DeleteUniqueOptionI256): + return GetAsDeleteUniqueOptionI256() == Other.GetAsDeleteUniqueOptionI256(); + case static_cast(EReducerTag::DeleteUniqueOptionI32): + return GetAsDeleteUniqueOptionI32() == Other.GetAsDeleteUniqueOptionI32(); + case static_cast(EReducerTag::DeleteUniqueOptionI64): + return GetAsDeleteUniqueOptionI64() == Other.GetAsDeleteUniqueOptionI64(); + case static_cast(EReducerTag::DeleteUniqueOptionI8): + return GetAsDeleteUniqueOptionI8() == Other.GetAsDeleteUniqueOptionI8(); + case static_cast(EReducerTag::DeleteUniqueOptionIdentity): + return GetAsDeleteUniqueOptionIdentity() == Other.GetAsDeleteUniqueOptionIdentity(); + case static_cast(EReducerTag::DeleteUniqueOptionString): + return GetAsDeleteUniqueOptionString() == Other.GetAsDeleteUniqueOptionString(); + case static_cast(EReducerTag::DeleteUniqueOptionU128): + return GetAsDeleteUniqueOptionU128() == Other.GetAsDeleteUniqueOptionU128(); + case static_cast(EReducerTag::DeleteUniqueOptionU16): + return GetAsDeleteUniqueOptionU16() == Other.GetAsDeleteUniqueOptionU16(); + case static_cast(EReducerTag::DeleteUniqueOptionU256): + return GetAsDeleteUniqueOptionU256() == Other.GetAsDeleteUniqueOptionU256(); + case static_cast(EReducerTag::DeleteUniqueOptionU32): + return GetAsDeleteUniqueOptionU32() == Other.GetAsDeleteUniqueOptionU32(); + case static_cast(EReducerTag::DeleteUniqueOptionU64): + return GetAsDeleteUniqueOptionU64() == Other.GetAsDeleteUniqueOptionU64(); + case static_cast(EReducerTag::DeleteUniqueOptionU8): + return GetAsDeleteUniqueOptionU8() == Other.GetAsDeleteUniqueOptionU8(); + case static_cast(EReducerTag::DeleteUniqueOptionUuid): + return GetAsDeleteUniqueOptionUuid() == Other.GetAsDeleteUniqueOptionUuid(); case static_cast(EReducerTag::DeleteUniqueString): return GetAsDeleteUniqueString() == Other.GetAsDeleteUniqueString(); case static_cast(EReducerTag::DeleteUniqueU128): @@ -6570,6 +8045,40 @@ struct TESTCLIENT_API FReducer return GetAsInsertUniqueI8() == Other.GetAsInsertUniqueI8(); case static_cast(EReducerTag::InsertUniqueIdentity): return GetAsInsertUniqueIdentity() == Other.GetAsInsertUniqueIdentity(); + case static_cast(EReducerTag::InsertUniqueOptionBool): + return GetAsInsertUniqueOptionBool() == Other.GetAsInsertUniqueOptionBool(); + case static_cast(EReducerTag::InsertUniqueOptionConnectionId): + return GetAsInsertUniqueOptionConnectionId() == Other.GetAsInsertUniqueOptionConnectionId(); + case static_cast(EReducerTag::InsertUniqueOptionI128): + return GetAsInsertUniqueOptionI128() == Other.GetAsInsertUniqueOptionI128(); + case static_cast(EReducerTag::InsertUniqueOptionI16): + return GetAsInsertUniqueOptionI16() == Other.GetAsInsertUniqueOptionI16(); + case static_cast(EReducerTag::InsertUniqueOptionI256): + return GetAsInsertUniqueOptionI256() == Other.GetAsInsertUniqueOptionI256(); + case static_cast(EReducerTag::InsertUniqueOptionI32): + return GetAsInsertUniqueOptionI32() == Other.GetAsInsertUniqueOptionI32(); + case static_cast(EReducerTag::InsertUniqueOptionI64): + return GetAsInsertUniqueOptionI64() == Other.GetAsInsertUniqueOptionI64(); + case static_cast(EReducerTag::InsertUniqueOptionI8): + return GetAsInsertUniqueOptionI8() == Other.GetAsInsertUniqueOptionI8(); + case static_cast(EReducerTag::InsertUniqueOptionIdentity): + return GetAsInsertUniqueOptionIdentity() == Other.GetAsInsertUniqueOptionIdentity(); + case static_cast(EReducerTag::InsertUniqueOptionString): + return GetAsInsertUniqueOptionString() == Other.GetAsInsertUniqueOptionString(); + case static_cast(EReducerTag::InsertUniqueOptionU128): + return GetAsInsertUniqueOptionU128() == Other.GetAsInsertUniqueOptionU128(); + case static_cast(EReducerTag::InsertUniqueOptionU16): + return GetAsInsertUniqueOptionU16() == Other.GetAsInsertUniqueOptionU16(); + case static_cast(EReducerTag::InsertUniqueOptionU256): + return GetAsInsertUniqueOptionU256() == Other.GetAsInsertUniqueOptionU256(); + case static_cast(EReducerTag::InsertUniqueOptionU32): + return GetAsInsertUniqueOptionU32() == Other.GetAsInsertUniqueOptionU32(); + case static_cast(EReducerTag::InsertUniqueOptionU64): + return GetAsInsertUniqueOptionU64() == Other.GetAsInsertUniqueOptionU64(); + case static_cast(EReducerTag::InsertUniqueOptionU8): + return GetAsInsertUniqueOptionU8() == Other.GetAsInsertUniqueOptionU8(); + case static_cast(EReducerTag::InsertUniqueOptionUuid): + return GetAsInsertUniqueOptionUuid() == Other.GetAsInsertUniqueOptionUuid(); case static_cast(EReducerTag::InsertUniqueString): return GetAsInsertUniqueString() == Other.GetAsInsertUniqueString(); case static_cast(EReducerTag::InsertUniqueU128): @@ -6704,6 +8213,40 @@ struct TESTCLIENT_API FReducer return GetAsUpdateUniqueI8() == Other.GetAsUpdateUniqueI8(); case static_cast(EReducerTag::UpdateUniqueIdentity): return GetAsUpdateUniqueIdentity() == Other.GetAsUpdateUniqueIdentity(); + case static_cast(EReducerTag::UpdateUniqueOptionBool): + return GetAsUpdateUniqueOptionBool() == Other.GetAsUpdateUniqueOptionBool(); + case static_cast(EReducerTag::UpdateUniqueOptionConnectionId): + return GetAsUpdateUniqueOptionConnectionId() == Other.GetAsUpdateUniqueOptionConnectionId(); + case static_cast(EReducerTag::UpdateUniqueOptionI128): + return GetAsUpdateUniqueOptionI128() == Other.GetAsUpdateUniqueOptionI128(); + case static_cast(EReducerTag::UpdateUniqueOptionI16): + return GetAsUpdateUniqueOptionI16() == Other.GetAsUpdateUniqueOptionI16(); + case static_cast(EReducerTag::UpdateUniqueOptionI256): + return GetAsUpdateUniqueOptionI256() == Other.GetAsUpdateUniqueOptionI256(); + case static_cast(EReducerTag::UpdateUniqueOptionI32): + return GetAsUpdateUniqueOptionI32() == Other.GetAsUpdateUniqueOptionI32(); + case static_cast(EReducerTag::UpdateUniqueOptionI64): + return GetAsUpdateUniqueOptionI64() == Other.GetAsUpdateUniqueOptionI64(); + case static_cast(EReducerTag::UpdateUniqueOptionI8): + return GetAsUpdateUniqueOptionI8() == Other.GetAsUpdateUniqueOptionI8(); + case static_cast(EReducerTag::UpdateUniqueOptionIdentity): + return GetAsUpdateUniqueOptionIdentity() == Other.GetAsUpdateUniqueOptionIdentity(); + case static_cast(EReducerTag::UpdateUniqueOptionString): + return GetAsUpdateUniqueOptionString() == Other.GetAsUpdateUniqueOptionString(); + case static_cast(EReducerTag::UpdateUniqueOptionU128): + return GetAsUpdateUniqueOptionU128() == Other.GetAsUpdateUniqueOptionU128(); + case static_cast(EReducerTag::UpdateUniqueOptionU16): + return GetAsUpdateUniqueOptionU16() == Other.GetAsUpdateUniqueOptionU16(); + case static_cast(EReducerTag::UpdateUniqueOptionU256): + return GetAsUpdateUniqueOptionU256() == Other.GetAsUpdateUniqueOptionU256(); + case static_cast(EReducerTag::UpdateUniqueOptionU32): + return GetAsUpdateUniqueOptionU32() == Other.GetAsUpdateUniqueOptionU32(); + case static_cast(EReducerTag::UpdateUniqueOptionU64): + return GetAsUpdateUniqueOptionU64() == Other.GetAsUpdateUniqueOptionU64(); + case static_cast(EReducerTag::UpdateUniqueOptionU8): + return GetAsUpdateUniqueOptionU8() == Other.GetAsUpdateUniqueOptionU8(); + case static_cast(EReducerTag::UpdateUniqueOptionUuid): + return GetAsUpdateUniqueOptionUuid() == Other.GetAsUpdateUniqueOptionUuid(); case static_cast(EReducerTag::UpdateUniqueString): return GetAsUpdateUniqueString() == Other.GetAsUpdateUniqueString(); case static_cast(EReducerTag::UpdateUniqueU128): @@ -7500,6 +9043,227 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary return Reducer.GetAsDeleteAllUniqueIdentity(); } + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionBool(const FDeleteAllUniqueOptionBoolArgs& Value) { + return FReducer::DeleteAllUniqueOptionBool(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionBool(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionBoolArgs GetAsDeleteAllUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionBool(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionConnectionId(const FDeleteAllUniqueOptionConnectionIdArgs& Value) { + return FReducer::DeleteAllUniqueOptionConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionConnectionIdArgs GetAsDeleteAllUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI128(const FDeleteAllUniqueOptionI128Args& Value) { + return FReducer::DeleteAllUniqueOptionI128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI128Args GetAsDeleteAllUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI16(const FDeleteAllUniqueOptionI16Args& Value) { + return FReducer::DeleteAllUniqueOptionI16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI16Args GetAsDeleteAllUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI256(const FDeleteAllUniqueOptionI256Args& Value) { + return FReducer::DeleteAllUniqueOptionI256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI256Args GetAsDeleteAllUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI32(const FDeleteAllUniqueOptionI32Args& Value) { + return FReducer::DeleteAllUniqueOptionI32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI32Args GetAsDeleteAllUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI64(const FDeleteAllUniqueOptionI64Args& Value) { + return FReducer::DeleteAllUniqueOptionI64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI64Args GetAsDeleteAllUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionI8(const FDeleteAllUniqueOptionI8Args& Value) { + return FReducer::DeleteAllUniqueOptionI8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionI8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionI8Args GetAsDeleteAllUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionI8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionIdentity(const FDeleteAllUniqueOptionIdentityArgs& Value) { + return FReducer::DeleteAllUniqueOptionIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionIdentityArgs GetAsDeleteAllUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionString(const FDeleteAllUniqueOptionStringArgs& Value) { + return FReducer::DeleteAllUniqueOptionString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionString(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionStringArgs GetAsDeleteAllUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU128(const FDeleteAllUniqueOptionU128Args& Value) { + return FReducer::DeleteAllUniqueOptionU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU128Args GetAsDeleteAllUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU16(const FDeleteAllUniqueOptionU16Args& Value) { + return FReducer::DeleteAllUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU16Args GetAsDeleteAllUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU256(const FDeleteAllUniqueOptionU256Args& Value) { + return FReducer::DeleteAllUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU256Args GetAsDeleteAllUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU32(const FDeleteAllUniqueOptionU32Args& Value) { + return FReducer::DeleteAllUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU32Args GetAsDeleteAllUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU64(const FDeleteAllUniqueOptionU64Args& Value) { + return FReducer::DeleteAllUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU64Args GetAsDeleteAllUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionU8(const FDeleteAllUniqueOptionU8Args& Value) { + return FReducer::DeleteAllUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionU8Args GetAsDeleteAllUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteAllUniqueOptionUuid(const FDeleteAllUniqueOptionUuidArgs& Value) { + return FReducer::DeleteAllUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteAllUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsDeleteAllUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteAllUniqueOptionUuidArgs GetAsDeleteAllUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteAllUniqueOptionUuid(); + } + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") static FReducer DeleteAllUniqueString(const FDeleteAllUniqueStringArgs& Value) { return FReducer::DeleteAllUniqueString(Value); @@ -8320,272 +10084,493 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) { - return FReducer::DeleteUniqueString(Value); + static FReducer DeleteUniqueOptionBool(const FDeleteUniqueOptionBoolArgs& Value) { + return FReducer::DeleteUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueString(); } + static bool IsDeleteUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueStringArgs GetAsDeleteUniqueString(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueString(); + static FDeleteUniqueOptionBoolArgs GetAsDeleteUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) { - return FReducer::DeleteUniqueU128(Value); + static FReducer DeleteUniqueOptionConnectionId(const FDeleteUniqueOptionConnectionIdArgs& Value) { + return FReducer::DeleteUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU128(); } + static bool IsDeleteUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU128Args GetAsDeleteUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU128(); + static FDeleteUniqueOptionConnectionIdArgs GetAsDeleteUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) { - return FReducer::DeleteUniqueU16(Value); + static FReducer DeleteUniqueOptionI128(const FDeleteUniqueOptionI128Args& Value) { + return FReducer::DeleteUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU16(); } + static bool IsDeleteUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU16Args GetAsDeleteUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU16(); + static FDeleteUniqueOptionI128Args GetAsDeleteUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) { - return FReducer::DeleteUniqueU256(Value); + static FReducer DeleteUniqueOptionI16(const FDeleteUniqueOptionI16Args& Value) { + return FReducer::DeleteUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU256(); } + static bool IsDeleteUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU256Args GetAsDeleteUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU256(); + static FDeleteUniqueOptionI16Args GetAsDeleteUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) { - return FReducer::DeleteUniqueU32(Value); + static FReducer DeleteUniqueOptionI256(const FDeleteUniqueOptionI256Args& Value) { + return FReducer::DeleteUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU32(); } + static bool IsDeleteUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU32Args GetAsDeleteUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU32(); + static FDeleteUniqueOptionI256Args GetAsDeleteUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) { - return FReducer::DeleteUniqueU64(Value); + static FReducer DeleteUniqueOptionI32(const FDeleteUniqueOptionI32Args& Value) { + return FReducer::DeleteUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU64(); } + static bool IsDeleteUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU64Args GetAsDeleteUniqueU64(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU64(); + static FDeleteUniqueOptionI32Args GetAsDeleteUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) { - return FReducer::DeleteUniqueU8(Value); + static FReducer DeleteUniqueOptionI64(const FDeleteUniqueOptionI64Args& Value) { + return FReducer::DeleteUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU8(); } + static bool IsDeleteUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueU8Args GetAsDeleteUniqueU8(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueU8(); + static FDeleteUniqueOptionI64Args GetAsDeleteUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) { - return FReducer::DeleteUniqueUuid(Value); + static FReducer DeleteUniqueOptionI8(const FDeleteUniqueOptionI8Args& Value) { + return FReducer::DeleteUniqueOptionI8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsDeleteUniqueUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueUuid(); } + static bool IsDeleteUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionI8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid(const FReducer& Reducer) { - return Reducer.GetAsDeleteUniqueUuid(); + static FDeleteUniqueOptionI8Args GetAsDeleteUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionI8(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) { - return FReducer::InsertCallTimestamp(Value); + static FReducer DeleteUniqueOptionIdentity(const FDeleteUniqueOptionIdentityArgs& Value) { + return FReducer::DeleteUniqueOptionIdentity(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallTimestamp(const FReducer& Reducer) { return Reducer.IsInsertCallTimestamp(); } + static bool IsDeleteUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionIdentity(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallTimestampArgs GetAsInsertCallTimestamp(const FReducer& Reducer) { - return Reducer.GetAsInsertCallTimestamp(); + static FDeleteUniqueOptionIdentityArgs GetAsDeleteUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionIdentity(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) { - return FReducer::InsertCallUuidV4(Value); + static FReducer DeleteUniqueOptionString(const FDeleteUniqueOptionStringArgs& Value) { + return FReducer::DeleteUniqueOptionString(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallUuidV4(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV4(); } + static bool IsDeleteUniqueOptionString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionString(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallUuidV4Args GetAsInsertCallUuidV4(const FReducer& Reducer) { - return Reducer.GetAsInsertCallUuidV4(); + static FDeleteUniqueOptionStringArgs GetAsDeleteUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionString(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) { - return FReducer::InsertCallUuidV7(Value); + static FReducer DeleteUniqueOptionU128(const FDeleteUniqueOptionU128Args& Value) { + return FReducer::DeleteUniqueOptionU128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallUuidV7(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV7(); } + static bool IsDeleteUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallUuidV7Args GetAsInsertCallUuidV7(const FReducer& Reducer) { - return Reducer.GetAsInsertCallUuidV7(); + static FDeleteUniqueOptionU128Args GetAsDeleteUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) { - return FReducer::InsertCallerOneConnectionId(Value); + static FReducer DeleteUniqueOptionU16(const FDeleteUniqueOptionU16Args& Value) { + return FReducer::DeleteUniqueOptionU16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerOneConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerOneConnectionId(); } + static bool IsDeleteUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerOneConnectionId(); + static FDeleteUniqueOptionU16Args GetAsDeleteUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) { - return FReducer::InsertCallerOneIdentity(Value); + static FReducer DeleteUniqueOptionU256(const FDeleteUniqueOptionU256Args& Value) { + return FReducer::DeleteUniqueOptionU256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerOneIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerOneIdentity(); } + static bool IsDeleteUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerOneIdentityArgs GetAsInsertCallerOneIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerOneIdentity(); + static FDeleteUniqueOptionU256Args GetAsDeleteUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerPkConnectionId(const FInsertCallerPkConnectionIdArgs& Value) { - return FReducer::InsertCallerPkConnectionId(Value); + static FReducer DeleteUniqueOptionU32(const FDeleteUniqueOptionU32Args& Value) { + return FReducer::DeleteUniqueOptionU32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerPkConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerPkConnectionId(); } + static bool IsDeleteUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerPkConnectionIdArgs GetAsInsertCallerPkConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerPkConnectionId(); + static FDeleteUniqueOptionU32Args GetAsDeleteUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerPkIdentity(const FInsertCallerPkIdentityArgs& Value) { - return FReducer::InsertCallerPkIdentity(Value); + static FReducer DeleteUniqueOptionU64(const FDeleteUniqueOptionU64Args& Value) { + return FReducer::DeleteUniqueOptionU64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerPkIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerPkIdentity(); } + static bool IsDeleteUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerPkIdentityArgs GetAsInsertCallerPkIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerPkIdentity(); + static FDeleteUniqueOptionU64Args GetAsDeleteUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerUniqueConnectionId(const FInsertCallerUniqueConnectionIdArgs& Value) { - return FReducer::InsertCallerUniqueConnectionId(Value); + static FReducer DeleteUniqueOptionU8(const FDeleteUniqueOptionU8Args& Value) { + return FReducer::DeleteUniqueOptionU8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerUniqueConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueConnectionId(); } + static bool IsDeleteUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionU8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerUniqueConnectionIdArgs GetAsInsertCallerUniqueConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerUniqueConnectionId(); + static FDeleteUniqueOptionU8Args GetAsDeleteUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionU8(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerUniqueIdentity(const FInsertCallerUniqueIdentityArgs& Value) { - return FReducer::InsertCallerUniqueIdentity(Value); + static FReducer DeleteUniqueOptionUuid(const FDeleteUniqueOptionUuidArgs& Value) { + return FReducer::DeleteUniqueOptionUuid(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerUniqueIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueIdentity(); } + static bool IsDeleteUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueOptionUuid(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerUniqueIdentityArgs GetAsInsertCallerUniqueIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerUniqueIdentity(); + static FDeleteUniqueOptionUuidArgs GetAsDeleteUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueOptionUuid(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerVecConnectionId(const FInsertCallerVecConnectionIdArgs& Value) { - return FReducer::InsertCallerVecConnectionId(Value); + static FReducer DeleteUniqueString(const FDeleteUniqueStringArgs& Value) { + return FReducer::DeleteUniqueString(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerVecConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerVecConnectionId(); } + static bool IsDeleteUniqueString(const FReducer& Reducer) { return Reducer.IsDeleteUniqueString(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerVecConnectionIdArgs GetAsInsertCallerVecConnectionId(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerVecConnectionId(); + static FDeleteUniqueStringArgs GetAsDeleteUniqueString(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueString(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertCallerVecIdentity(const FInsertCallerVecIdentityArgs& Value) { - return FReducer::InsertCallerVecIdentity(Value); + static FReducer DeleteUniqueU128(const FDeleteUniqueU128Args& Value) { + return FReducer::DeleteUniqueU128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertCallerVecIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerVecIdentity(); } + static bool IsDeleteUniqueU128(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertCallerVecIdentityArgs GetAsInsertCallerVecIdentity(const FReducer& Reducer) { - return Reducer.GetAsInsertCallerVecIdentity(); + static FDeleteUniqueU128Args GetAsDeleteUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertIntoBtreeU32(const FInsertIntoBtreeU32Args& Value) { - return FReducer::InsertIntoBtreeU32(Value); + static FReducer DeleteUniqueU16(const FDeleteUniqueU16Args& Value) { + return FReducer::DeleteUniqueU16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertIntoBtreeU32(const FReducer& Reducer) { return Reducer.IsInsertIntoBtreeU32(); } + static bool IsDeleteUniqueU16(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertIntoBtreeU32Args GetAsInsertIntoBtreeU32(const FReducer& Reducer) { - return Reducer.GetAsInsertIntoBtreeU32(); + static FDeleteUniqueU16Args GetAsDeleteUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertIntoIndexedSimpleEnum(const FInsertIntoIndexedSimpleEnumArgs& Value) { - return FReducer::InsertIntoIndexedSimpleEnum(Value); + static FReducer DeleteUniqueU256(const FDeleteUniqueU256Args& Value) { + return FReducer::DeleteUniqueU256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { return Reducer.IsInsertIntoIndexedSimpleEnum(); } + static bool IsDeleteUniqueU256(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU256Args GetAsDeleteUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU32(const FDeleteUniqueU32Args& Value) { + return FReducer::DeleteUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU32(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU32Args GetAsDeleteUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU64(const FDeleteUniqueU64Args& Value) { + return FReducer::DeleteUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU64(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU64Args GetAsDeleteUniqueU64(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueU8(const FDeleteUniqueU8Args& Value) { + return FReducer::DeleteUniqueU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueU8(const FReducer& Reducer) { return Reducer.IsDeleteUniqueU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueU8Args GetAsDeleteUniqueU8(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer DeleteUniqueUuid(const FDeleteUniqueUuidArgs& Value) { + return FReducer::DeleteUniqueUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsDeleteUniqueUuid(const FReducer& Reducer) { return Reducer.IsDeleteUniqueUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FDeleteUniqueUuidArgs GetAsDeleteUniqueUuid(const FReducer& Reducer) { + return Reducer.GetAsDeleteUniqueUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallTimestamp(const FInsertCallTimestampArgs& Value) { + return FReducer::InsertCallTimestamp(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallTimestamp(const FReducer& Reducer) { return Reducer.IsInsertCallTimestamp(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallTimestampArgs GetAsInsertCallTimestamp(const FReducer& Reducer) { + return Reducer.GetAsInsertCallTimestamp(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallUuidV4(const FInsertCallUuidV4Args& Value) { + return FReducer::InsertCallUuidV4(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallUuidV4(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV4(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallUuidV4Args GetAsInsertCallUuidV4(const FReducer& Reducer) { + return Reducer.GetAsInsertCallUuidV4(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallUuidV7(const FInsertCallUuidV7Args& Value) { + return FReducer::InsertCallUuidV7(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallUuidV7(const FReducer& Reducer) { return Reducer.IsInsertCallUuidV7(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallUuidV7Args GetAsInsertCallUuidV7(const FReducer& Reducer) { + return Reducer.GetAsInsertCallUuidV7(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerOneConnectionId(const FInsertCallerOneConnectionIdArgs& Value) { + return FReducer::InsertCallerOneConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerOneConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerOneConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerOneConnectionIdArgs GetAsInsertCallerOneConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerOneConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerOneIdentity(const FInsertCallerOneIdentityArgs& Value) { + return FReducer::InsertCallerOneIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerOneIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerOneIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerOneIdentityArgs GetAsInsertCallerOneIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerOneIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerPkConnectionId(const FInsertCallerPkConnectionIdArgs& Value) { + return FReducer::InsertCallerPkConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerPkConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerPkConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerPkConnectionIdArgs GetAsInsertCallerPkConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerPkConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerPkIdentity(const FInsertCallerPkIdentityArgs& Value) { + return FReducer::InsertCallerPkIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerPkIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerPkIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerPkIdentityArgs GetAsInsertCallerPkIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerPkIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerUniqueConnectionId(const FInsertCallerUniqueConnectionIdArgs& Value) { + return FReducer::InsertCallerUniqueConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerUniqueConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerUniqueConnectionIdArgs GetAsInsertCallerUniqueConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerUniqueConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerUniqueIdentity(const FInsertCallerUniqueIdentityArgs& Value) { + return FReducer::InsertCallerUniqueIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerUniqueIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerUniqueIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerUniqueIdentityArgs GetAsInsertCallerUniqueIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerUniqueIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerVecConnectionId(const FInsertCallerVecConnectionIdArgs& Value) { + return FReducer::InsertCallerVecConnectionId(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerVecConnectionId(const FReducer& Reducer) { return Reducer.IsInsertCallerVecConnectionId(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerVecConnectionIdArgs GetAsInsertCallerVecConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerVecConnectionId(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertCallerVecIdentity(const FInsertCallerVecIdentityArgs& Value) { + return FReducer::InsertCallerVecIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertCallerVecIdentity(const FReducer& Reducer) { return Reducer.IsInsertCallerVecIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertCallerVecIdentityArgs GetAsInsertCallerVecIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertCallerVecIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertIntoBtreeU32(const FInsertIntoBtreeU32Args& Value) { + return FReducer::InsertIntoBtreeU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertIntoBtreeU32(const FReducer& Reducer) { return Reducer.IsInsertIntoBtreeU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertIntoBtreeU32Args GetAsInsertIntoBtreeU32(const FReducer& Reducer) { + return Reducer.GetAsInsertIntoBtreeU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertIntoIndexedSimpleEnum(const FInsertIntoIndexedSimpleEnumArgs& Value) { + return FReducer::InsertIntoIndexedSimpleEnum(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { return Reducer.IsInsertIntoIndexedSimpleEnum(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") static FInsertIntoIndexedSimpleEnumArgs GetAsInsertIntoIndexedSimpleEnum(const FReducer& Reducer) { @@ -9516,93 +11501,314 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { - return FReducer::InsertUniqueString(Value); + static FReducer InsertUniqueOptionBool(const FInsertUniqueOptionBoolArgs& Value) { + return FReducer::InsertUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueString(const FReducer& Reducer) { return Reducer.IsInsertUniqueString(); } + static bool IsInsertUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueStringArgs GetAsInsertUniqueString(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueString(); + static FInsertUniqueOptionBoolArgs GetAsInsertUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU128(const FInsertUniqueU128Args& Value) { - return FReducer::InsertUniqueU128(Value); + static FReducer InsertUniqueOptionConnectionId(const FInsertUniqueOptionConnectionIdArgs& Value) { + return FReducer::InsertUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueU128(); } + static bool IsInsertUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU128Args GetAsInsertUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU128(); + static FInsertUniqueOptionConnectionIdArgs GetAsInsertUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU16(const FInsertUniqueU16Args& Value) { - return FReducer::InsertUniqueU16(Value); + static FReducer InsertUniqueOptionI128(const FInsertUniqueOptionI128Args& Value) { + return FReducer::InsertUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueU16(); } + static bool IsInsertUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU16Args GetAsInsertUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU16(); + static FInsertUniqueOptionI128Args GetAsInsertUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU256(const FInsertUniqueU256Args& Value) { - return FReducer::InsertUniqueU256(Value); + static FReducer InsertUniqueOptionI16(const FInsertUniqueOptionI16Args& Value) { + return FReducer::InsertUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueU256(); } + static bool IsInsertUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU256Args GetAsInsertUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU256(); + static FInsertUniqueOptionI16Args GetAsInsertUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU32(const FInsertUniqueU32Args& Value) { - return FReducer::InsertUniqueU32(Value); + static FReducer InsertUniqueOptionI256(const FInsertUniqueOptionI256Args& Value) { + return FReducer::InsertUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32(); } + static bool IsInsertUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU32Args GetAsInsertUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU32(); + static FInsertUniqueOptionI256Args GetAsInsertUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU32UpdatePkU32(const FInsertUniqueU32UpdatePkU32Args& Value) { - return FReducer::InsertUniqueU32UpdatePkU32(Value); + static FReducer InsertUniqueOptionI32(const FInsertUniqueOptionI32Args& Value) { + return FReducer::InsertUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32UpdatePkU32(); } + static bool IsInsertUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU32UpdatePkU32Args GetAsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { - return Reducer.GetAsInsertUniqueU32UpdatePkU32(); + static FInsertUniqueOptionI32Args GetAsInsertUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer InsertUniqueU64(const FInsertUniqueU64Args& Value) { - return FReducer::InsertUniqueU64(Value); + static FReducer InsertUniqueOptionI64(const FInsertUniqueOptionI64Args& Value) { + return FReducer::InsertUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsInsertUniqueU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueU64(); } + static bool IsInsertUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FInsertUniqueU64Args GetAsInsertUniqueU64(const FReducer& Reducer) { + static FInsertUniqueOptionI64Args GetAsInsertUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionI8(const FInsertUniqueOptionI8Args& Value) { + return FReducer::InsertUniqueOptionI8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionI8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionI8Args GetAsInsertUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionI8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionIdentity(const FInsertUniqueOptionIdentityArgs& Value) { + return FReducer::InsertUniqueOptionIdentity(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionIdentity(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionIdentityArgs GetAsInsertUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionIdentity(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionString(const FInsertUniqueOptionStringArgs& Value) { + return FReducer::InsertUniqueOptionString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionString(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionStringArgs GetAsInsertUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU128(const FInsertUniqueOptionU128Args& Value) { + return FReducer::InsertUniqueOptionU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU128Args GetAsInsertUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU16(const FInsertUniqueOptionU16Args& Value) { + return FReducer::InsertUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU16Args GetAsInsertUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU256(const FInsertUniqueOptionU256Args& Value) { + return FReducer::InsertUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU256Args GetAsInsertUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU32(const FInsertUniqueOptionU32Args& Value) { + return FReducer::InsertUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU32Args GetAsInsertUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU64(const FInsertUniqueOptionU64Args& Value) { + return FReducer::InsertUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU64Args GetAsInsertUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionU8(const FInsertUniqueOptionU8Args& Value) { + return FReducer::InsertUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionU8Args GetAsInsertUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueOptionUuid(const FInsertUniqueOptionUuidArgs& Value) { + return FReducer::InsertUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsInsertUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueOptionUuidArgs GetAsInsertUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueOptionUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueString(const FInsertUniqueStringArgs& Value) { + return FReducer::InsertUniqueString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueString(const FReducer& Reducer) { return Reducer.IsInsertUniqueString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueStringArgs GetAsInsertUniqueString(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU128(const FInsertUniqueU128Args& Value) { + return FReducer::InsertUniqueU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU128(const FReducer& Reducer) { return Reducer.IsInsertUniqueU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU128Args GetAsInsertUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU16(const FInsertUniqueU16Args& Value) { + return FReducer::InsertUniqueU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU16(const FReducer& Reducer) { return Reducer.IsInsertUniqueU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU16Args GetAsInsertUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU256(const FInsertUniqueU256Args& Value) { + return FReducer::InsertUniqueU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU256(const FReducer& Reducer) { return Reducer.IsInsertUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU256Args GetAsInsertUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU32(const FInsertUniqueU32Args& Value) { + return FReducer::InsertUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU32Args GetAsInsertUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU32UpdatePkU32(const FInsertUniqueU32UpdatePkU32Args& Value) { + return FReducer::InsertUniqueU32UpdatePkU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { return Reducer.IsInsertUniqueU32UpdatePkU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU32UpdatePkU32Args GetAsInsertUniqueU32UpdatePkU32(const FReducer& Reducer) { + return Reducer.GetAsInsertUniqueU32UpdatePkU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer InsertUniqueU64(const FInsertUniqueU64Args& Value) { + return FReducer::InsertUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsInsertUniqueU64(const FReducer& Reducer) { return Reducer.IsInsertUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FInsertUniqueU64Args GetAsInsertUniqueU64(const FReducer& Reducer) { return Reducer.GetAsInsertUniqueU64(); } @@ -10387,150 +12593,371 @@ class TESTCLIENT_API UReducerBpLib : public UBlueprintFunctionLibrary } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) { - return FReducer::UpdateUniqueString(Value); + static FReducer UpdateUniqueOptionBool(const FUpdateUniqueOptionBoolArgs& Value) { + return FReducer::UpdateUniqueOptionBool(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueString(); } + static bool IsUpdateUniqueOptionBool(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionBool(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueStringArgs GetAsUpdateUniqueString(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueString(); + static FUpdateUniqueOptionBoolArgs GetAsUpdateUniqueOptionBool(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionBool(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) { - return FReducer::UpdateUniqueU128(Value); + static FReducer UpdateUniqueOptionConnectionId(const FUpdateUniqueOptionConnectionIdArgs& Value) { + return FReducer::UpdateUniqueOptionConnectionId(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU128(); } + static bool IsUpdateUniqueOptionConnectionId(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionConnectionId(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU128Args GetAsUpdateUniqueU128(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU128(); + static FUpdateUniqueOptionConnectionIdArgs GetAsUpdateUniqueOptionConnectionId(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionConnectionId(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) { - return FReducer::UpdateUniqueU16(Value); + static FReducer UpdateUniqueOptionI128(const FUpdateUniqueOptionI128Args& Value) { + return FReducer::UpdateUniqueOptionI128(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU16(); } + static bool IsUpdateUniqueOptionI128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI128(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU16Args GetAsUpdateUniqueU16(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU16(); + static FUpdateUniqueOptionI128Args GetAsUpdateUniqueOptionI128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI128(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) { - return FReducer::UpdateUniqueU256(Value); + static FReducer UpdateUniqueOptionI16(const FUpdateUniqueOptionI16Args& Value) { + return FReducer::UpdateUniqueOptionI16(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU256(); } + static bool IsUpdateUniqueOptionI16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI16(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU256Args GetAsUpdateUniqueU256(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU256(); + static FUpdateUniqueOptionI16Args GetAsUpdateUniqueOptionI16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI16(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) { - return FReducer::UpdateUniqueU32(Value); + static FReducer UpdateUniqueOptionI256(const FUpdateUniqueOptionI256Args& Value) { + return FReducer::UpdateUniqueOptionI256(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU32(); } + static bool IsUpdateUniqueOptionI256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI256(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU32Args GetAsUpdateUniqueU32(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU32(); + static FUpdateUniqueOptionI256Args GetAsUpdateUniqueOptionI256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI256(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) { - return FReducer::UpdateUniqueU64(Value); + static FReducer UpdateUniqueOptionI32(const FUpdateUniqueOptionI32Args& Value) { + return FReducer::UpdateUniqueOptionI32(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU64(); } + static bool IsUpdateUniqueOptionI32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI32(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU64Args GetAsUpdateUniqueU64(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU64(); + static FUpdateUniqueOptionI32Args GetAsUpdateUniqueOptionI32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI32(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) { - return FReducer::UpdateUniqueU8(Value); + static FReducer UpdateUniqueOptionI64(const FUpdateUniqueOptionI64Args& Value) { + return FReducer::UpdateUniqueOptionI64(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU8(); } + static bool IsUpdateUniqueOptionI64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI64(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueU8Args GetAsUpdateUniqueU8(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueU8(); + static FUpdateUniqueOptionI64Args GetAsUpdateUniqueOptionI64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI64(); } UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") - static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) { - return FReducer::UpdateUniqueUuid(Value); + static FReducer UpdateUniqueOptionI8(const FUpdateUniqueOptionI8Args& Value) { + return FReducer::UpdateUniqueOptionI8(Value); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static bool IsUpdateUniqueUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueUuid(); } + static bool IsUpdateUniqueOptionI8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionI8(); } UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") - static FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid(const FReducer& Reducer) { - return Reducer.GetAsUpdateUniqueUuid(); + static FUpdateUniqueOptionI8Args GetAsUpdateUniqueOptionI8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionI8(); } -}; -/** Metadata describing a reducer run. */ -USTRUCT(BlueprintType) -struct TESTCLIENT_API FTestClientReducerEvent -{ - GENERATED_BODY() + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionIdentity(const FUpdateUniqueOptionIdentityArgs& Value) { + return FReducer::UpdateUniqueOptionIdentity(Value); + } - /** Timestamp for when the reducer executed */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBTimestamp Timestamp; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionIdentity(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionIdentity(); } - /** Result status of the reducer */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBStatus Status; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionIdentityArgs GetAsUpdateUniqueOptionIdentity(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionIdentity(); + } - /** Identity that initiated the call */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBIdentity CallerIdentity; + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionString(const FUpdateUniqueOptionStringArgs& Value) { + return FReducer::UpdateUniqueOptionString(Value); + } - /** Connection ID for the caller */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FSpacetimeDBConnectionId CallerConnectionId; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionString(); } - /** Energy consumed while executing */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FEnergyQuantaType EnergyConsumed; + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionStringArgs GetAsUpdateUniqueOptionString(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionString(); + } - /** Detailed call information */ - UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") - FReducer Reducer; + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU128(const FUpdateUniqueOptionU128Args& Value) { + return FReducer::UpdateUniqueOptionU128(Value); + } - FORCEINLINE bool operator==(const FTestClientReducerEvent& Other) const - { - return Status == Other.Status && Timestamp == Other.Timestamp && CallerIdentity == Other.CallerIdentity && - CallerConnectionId == Other.CallerConnectionId && EnergyConsumed == Other.EnergyConsumed && - Reducer == Other.Reducer; - } + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU128(); } - FORCEINLINE bool operator!=(const FTestClientReducerEvent& Other) const - { - return !(*this == Other); + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU128Args GetAsUpdateUniqueOptionU128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU16(const FUpdateUniqueOptionU16Args& Value) { + return FReducer::UpdateUniqueOptionU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU16Args GetAsUpdateUniqueOptionU16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU256(const FUpdateUniqueOptionU256Args& Value) { + return FReducer::UpdateUniqueOptionU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU256Args GetAsUpdateUniqueOptionU256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU32(const FUpdateUniqueOptionU32Args& Value) { + return FReducer::UpdateUniqueOptionU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU32Args GetAsUpdateUniqueOptionU32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU64(const FUpdateUniqueOptionU64Args& Value) { + return FReducer::UpdateUniqueOptionU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU64Args GetAsUpdateUniqueOptionU64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionU8(const FUpdateUniqueOptionU8Args& Value) { + return FReducer::UpdateUniqueOptionU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionU8Args GetAsUpdateUniqueOptionU8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueOptionUuid(const FUpdateUniqueOptionUuidArgs& Value) { + return FReducer::UpdateUniqueOptionUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueOptionUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueOptionUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueOptionUuidArgs GetAsUpdateUniqueOptionUuid(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueOptionUuid(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueString(const FUpdateUniqueStringArgs& Value) { + return FReducer::UpdateUniqueString(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueString(const FReducer& Reducer) { return Reducer.IsUpdateUniqueString(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueStringArgs GetAsUpdateUniqueString(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueString(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU128(const FUpdateUniqueU128Args& Value) { + return FReducer::UpdateUniqueU128(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU128(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU128(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU128Args GetAsUpdateUniqueU128(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU128(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU16(const FUpdateUniqueU16Args& Value) { + return FReducer::UpdateUniqueU16(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU16(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU16(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU16Args GetAsUpdateUniqueU16(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU16(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU256(const FUpdateUniqueU256Args& Value) { + return FReducer::UpdateUniqueU256(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU256(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU256(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU256Args GetAsUpdateUniqueU256(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU256(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU32(const FUpdateUniqueU32Args& Value) { + return FReducer::UpdateUniqueU32(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU32(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU32(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU32Args GetAsUpdateUniqueU32(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU32(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU64(const FUpdateUniqueU64Args& Value) { + return FReducer::UpdateUniqueU64(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU64(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU64(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU64Args GetAsUpdateUniqueU64(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU64(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueU8(const FUpdateUniqueU8Args& Value) { + return FReducer::UpdateUniqueU8(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueU8(const FReducer& Reducer) { return Reducer.IsUpdateUniqueU8(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueU8Args GetAsUpdateUniqueU8(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueU8(); + } + + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|Reducer") + static FReducer UpdateUniqueUuid(const FUpdateUniqueUuidArgs& Value) { + return FReducer::UpdateUniqueUuid(Value); + } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static bool IsUpdateUniqueUuid(const FReducer& Reducer) { return Reducer.IsUpdateUniqueUuid(); } + + UFUNCTION(BlueprintPure, Category = "SpacetimeDB|Reducer") + static FUpdateUniqueUuidArgs GetAsUpdateUniqueUuid(const FReducer& Reducer) { + return Reducer.GetAsUpdateUniqueUuid(); + } +}; + +/** Metadata describing a reducer run. */ +USTRUCT(BlueprintType) +struct TESTCLIENT_API FTestClientReducerEvent +{ + GENERATED_BODY() + + /** Timestamp for when the reducer executed */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBTimestamp Timestamp; + + /** Result status of the reducer */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBStatus Status; + + /** Identity that initiated the call */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBIdentity CallerIdentity; + + /** Connection ID for the caller */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FSpacetimeDBConnectionId CallerConnectionId; + + /** Energy consumed while executing */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FEnergyQuantaType EnergyConsumed; + + /** Detailed call information */ + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB") + FReducer Reducer; + + FORCEINLINE bool operator==(const FTestClientReducerEvent& Other) const + { + return Status == Other.Status && Timestamp == Other.Timestamp && CallerIdentity == Other.CallerIdentity && + CallerConnectionId == Other.CallerConnectionId && EnergyConsumed == Other.EnergyConsumed && + Reducer == Other.Reducer; + } + + FORCEINLINE bool operator!=(const FTestClientReducerEvent& Other) const + { + return !(*this == Other); } }; @@ -11119,6 +13546,57 @@ class TESTCLIENT_API URemoteTables : public UObject UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") UUniqueIdentityTable* UniqueIdentity; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionBoolTable* UniqueOptionBool; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionConnectionIdTable* UniqueOptionConnectionId; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI128Table* UniqueOptionI128; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI16Table* UniqueOptionI16; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI256Table* UniqueOptionI256; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI32Table* UniqueOptionI32; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI64Table* UniqueOptionI64; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionI8Table* UniqueOptionI8; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionIdentityTable* UniqueOptionIdentity; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionStringTable* UniqueOptionString; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU128Table* UniqueOptionU128; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU16Table* UniqueOptionU16; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU256Table* UniqueOptionU256; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU32Table* UniqueOptionU32; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU64Table* UniqueOptionU64; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionU8Table* UniqueOptionU8; + + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") + UUniqueOptionUuidTable* UniqueOptionUuid; + UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB") UUniqueStringTable* UniqueString; @@ -12088,58 +14566,313 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeDeleteAllUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueStringHandler, + FDeleteAllUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueStringHandler OnDeleteAllUniqueString; + FDeleteAllUniqueOptionBoolHandler OnDeleteAllUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteAllUniqueString(const FString& S, const int32 Data); + void DeleteAllUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args); - bool InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args); + bool InvokeDeleteAllUniqueOptionBool(const FReducerEventContext& Context, const UDeleteAllUniqueOptionBoolReducer* Args); + bool InvokeDeleteAllUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU128Handler, + FDeleteAllUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueU128Handler OnDeleteAllUniqueU128; + FDeleteAllUniqueOptionConnectionIdHandler OnDeleteAllUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void DeleteAllUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args); - bool InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args); + bool InvokeDeleteAllUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteAllUniqueOptionConnectionIdReducer* Args); + bool InvokeDeleteAllUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU16Handler, + FDeleteAllUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FDeleteAllUniqueU16Handler OnDeleteAllUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI128Handler OnDeleteAllUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void DeleteAllUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args); - bool InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args); + bool InvokeDeleteAllUniqueOptionI128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI128Reducer* Args); + bool InvokeDeleteAllUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FDeleteAllUniqueU256Handler, + FDeleteAllUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteAllUniqueU256Handler OnDeleteAllUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FDeleteAllUniqueOptionI16Handler OnDeleteAllUniqueOptionI16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void DeleteAllUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI16Reducer* Args); + bool InvokeDeleteAllUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI256Handler OnDeleteAllUniqueOptionI256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI256Reducer* Args); + bool InvokeDeleteAllUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt32, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI32Handler OnDeleteAllUniqueOptionI32; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI32Reducer* Args); + bool InvokeDeleteAllUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt64, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionI64Handler OnDeleteAllUniqueOptionI64; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI64Reducer* Args); + bool InvokeDeleteAllUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionI8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FDeleteAllUniqueOptionI8Handler OnDeleteAllUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void DeleteAllUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionI8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionI8Reducer* Args); + bool InvokeDeleteAllUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionIdentityHandler OnDeleteAllUniqueOptionIdentity; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); + + bool InvokeDeleteAllUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteAllUniqueOptionIdentityReducer* Args); + bool InvokeDeleteAllUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionStringHandler OnDeleteAllUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeDeleteAllUniqueOptionString(const FReducerEventContext& Context, const UDeleteAllUniqueOptionStringReducer* Args); + bool InvokeDeleteAllUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU128Handler OnDeleteAllUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU128(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU128Reducer* Args); + bool InvokeDeleteAllUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FDeleteAllUniqueOptionU16Handler OnDeleteAllUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void DeleteAllUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU16(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU16Reducer* Args); + bool InvokeDeleteAllUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU256Handler OnDeleteAllUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU256(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU256Reducer* Args); + bool InvokeDeleteAllUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FDeleteAllUniqueOptionU32Handler OnDeleteAllUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void DeleteAllUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU32(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU32Reducer* Args); + bool InvokeDeleteAllUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FDeleteAllUniqueOptionU64Handler OnDeleteAllUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void DeleteAllUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU64(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU64Reducer* Args); + bool InvokeDeleteAllUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionU8Handler OnDeleteAllUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeDeleteAllUniqueOptionU8(const FReducerEventContext& Context, const UDeleteAllUniqueOptionU8Reducer* Args); + bool InvokeDeleteAllUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueOptionUuidHandler OnDeleteAllUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeDeleteAllUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteAllUniqueOptionUuidReducer* Args); + bool InvokeDeleteAllUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueStringHandler OnDeleteAllUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueString(const FString& S, const int32 Data); + + bool InvokeDeleteAllUniqueString(const FReducerEventContext& Context, const UDeleteAllUniqueStringReducer* Args); + bool InvokeDeleteAllUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueU128Handler OnDeleteAllUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteAllUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeDeleteAllUniqueU128(const FReducerEventContext& Context, const UDeleteAllUniqueU128Reducer* Args); + bool InvokeDeleteAllUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FDeleteAllUniqueU16Handler OnDeleteAllUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void DeleteAllUniqueU16(const uint16 N, const int32 Data); + + bool InvokeDeleteAllUniqueU16(const FReducerEventContext& Context, const UDeleteAllUniqueU16Reducer* Args); + bool InvokeDeleteAllUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteAllUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FDeleteAllUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteAllUniqueU256Handler OnDeleteAllUniqueU256; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") void DeleteAllUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); @@ -12979,149 +15712,387 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeDeleteUniqueIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueStringHandler, + FDeleteUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S + FTestClientOptionalBool, B ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueStringHandler OnDeleteUniqueString; + FDeleteUniqueOptionBoolHandler OnDeleteUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueString(const FString& S); + void DeleteUniqueOptionBool(const FTestClientOptionalBool B); - bool InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args); - bool InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args); + bool InvokeDeleteUniqueOptionBool(const FReducerEventContext& Context, const UDeleteUniqueOptionBoolReducer* Args); + bool InvokeDeleteUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU128Handler, + FDeleteUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N + const FTestClientOptionalConnectionId&, A ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU128Handler OnDeleteUniqueU128; + FDeleteUniqueOptionConnectionIdHandler OnDeleteUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU128(const FSpacetimeDBUInt128& N); + void DeleteUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A); - bool InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args); - bool InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args); + bool InvokeDeleteUniqueOptionConnectionId(const FReducerEventContext& Context, const UDeleteUniqueOptionConnectionIdReducer* Args); + bool InvokeDeleteUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU16Handler, + FDeleteUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N + const FTestClientOptionalInt128&, N ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FDeleteUniqueU16Handler OnDeleteUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI128Handler OnDeleteUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void DeleteUniqueU16(const uint16 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI128(const FTestClientOptionalInt128& N); - bool InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args); - bool InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args); + bool InvokeDeleteUniqueOptionI128(const FReducerEventContext& Context, const UDeleteUniqueOptionI128Reducer* Args); + bool InvokeDeleteUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU256Handler, + FDeleteUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N + FTestClientOptionalInt16, N ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU256Handler OnDeleteUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FDeleteUniqueOptionI16Handler OnDeleteUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU256(const FSpacetimeDBUInt256& N); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void DeleteUniqueOptionI16(const FTestClientOptionalInt16 N); - bool InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args); - bool InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args); + bool InvokeDeleteUniqueOptionI16(const FReducerEventContext& Context, const UDeleteUniqueOptionI16Reducer* Args); + bool InvokeDeleteUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU32Handler, + FDeleteUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N + const FTestClientOptionalInt256&, N ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FDeleteUniqueU32Handler OnDeleteUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI256Handler OnDeleteUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void DeleteUniqueU32(const uint32 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI256(const FTestClientOptionalInt256& N); - bool InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args); - bool InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args); + bool InvokeDeleteUniqueOptionI256(const FReducerEventContext& Context, const UDeleteUniqueOptionI256Reducer* Args); + bool InvokeDeleteUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI256Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU64Handler, + FDeleteUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint64, N + FTestClientOptionalInt32, N ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FDeleteUniqueU64Handler OnDeleteUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionI32Handler OnDeleteUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void DeleteUniqueU64(const uint64 N); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionI32(const FTestClientOptionalInt32 N); - bool InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args); - bool InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args); + bool InvokeDeleteUniqueOptionI32(const FReducerEventContext& Context, const UDeleteUniqueOptionI32Reducer* Args); + bool InvokeDeleteUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueU8Handler, + FDeleteUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint8, N + FTestClientOptionalInt64, N ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueU8Handler OnDeleteUniqueU8; + FDeleteUniqueOptionI64Handler OnDeleteUniqueOptionI64; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueU8(const uint8 N); + void DeleteUniqueOptionI64(const FTestClientOptionalInt64 N); - bool InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args); - bool InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args); + bool InvokeDeleteUniqueOptionI64(const FReducerEventContext& Context, const UDeleteUniqueOptionI64Reducer* Args); + bool InvokeDeleteUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( - FDeleteUniqueUuidHandler, + FDeleteUniqueOptionI8Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUuid&, U + FTestClientOptionalInt8, N ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FDeleteUniqueUuidHandler OnDeleteUniqueUuid; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FDeleteUniqueOptionI8Handler OnDeleteUniqueOptionI8; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void DeleteUniqueUuid(const FSpacetimeDBUuid& U); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void DeleteUniqueOptionI8(const FTestClientOptionalInt8 N); - bool InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args); - bool InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args); + bool InvokeDeleteUniqueOptionI8(const FReducerEventContext& Context, const UDeleteUniqueOptionI8Reducer* Args); + bool InvokeDeleteUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionI8Args& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallTimestampHandler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallTimestampHandler OnInsertCallTimestamp; + FDeleteUniqueOptionIdentityHandler OnDeleteUniqueOptionIdentity; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertCallTimestamp(); + void DeleteUniqueOptionIdentity(const FTestClientOptionalIdentity& I); - bool InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args); - bool InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args); + bool InvokeDeleteUniqueOptionIdentity(const FReducerEventContext& Context, const UDeleteUniqueOptionIdentityReducer* Args); + bool InvokeDeleteUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionIdentityArgs& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallUuidV4Handler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallUuidV4Handler OnInsertCallUuidV4; + FDeleteUniqueOptionStringHandler OnDeleteUniqueOptionString; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertCallUuidV4(); + void DeleteUniqueOptionString(const FTestClientOptionalString& S); - bool InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args); - bool InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args); + bool InvokeDeleteUniqueOptionString(const FReducerEventContext& Context, const UDeleteUniqueOptionStringReducer* Args); + bool InvokeDeleteUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionStringArgs& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( - FInsertCallUuidV7Handler, - const FReducerEventContext&, Context + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertCallUuidV7Handler OnInsertCallUuidV7; + FDeleteUniqueOptionU128Handler OnDeleteUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU128(const FTestClientOptionalUInt128& N); + + bool InvokeDeleteUniqueOptionU128(const FReducerEventContext& Context, const UDeleteUniqueOptionU128Reducer* Args); + bool InvokeDeleteUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FDeleteUniqueOptionU16Handler OnDeleteUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void DeleteUniqueOptionU16(const FTestClientOptionalUInt16 N); + + bool InvokeDeleteUniqueOptionU16(const FReducerEventContext& Context, const UDeleteUniqueOptionU16Reducer* Args); + bool InvokeDeleteUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionU256Handler OnDeleteUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU256(const FTestClientOptionalUInt256& N); + + bool InvokeDeleteUniqueOptionU256(const FReducerEventContext& Context, const UDeleteUniqueOptionU256Reducer* Args); + bool InvokeDeleteUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FDeleteUniqueOptionU32Handler OnDeleteUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void DeleteUniqueOptionU32(const FTestClientOptionalUInt32 N); + + bool InvokeDeleteUniqueOptionU32(const FReducerEventContext& Context, const UDeleteUniqueOptionU32Reducer* Args); + bool InvokeDeleteUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FDeleteUniqueOptionU64Handler OnDeleteUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void DeleteUniqueOptionU64(const FTestClientOptionalUInt64 N); + + bool InvokeDeleteUniqueOptionU64(const FReducerEventContext& Context, const UDeleteUniqueOptionU64Reducer* Args); + bool InvokeDeleteUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionU8Handler OnDeleteUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionU8(const FTestClientOptionalUInt8 N); + + bool InvokeDeleteUniqueOptionU8(const FReducerEventContext& Context, const UDeleteUniqueOptionU8Reducer* Args); + bool InvokeDeleteUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueOptionUuidHandler OnDeleteUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueOptionUuid(const FTestClientOptionalUuid& U); + + bool InvokeDeleteUniqueOptionUuid(const FReducerEventContext& Context, const UDeleteUniqueOptionUuidReducer* Args); + bool InvokeDeleteUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueStringHandler OnDeleteUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueString(const FString& S); + + bool InvokeDeleteUniqueString(const FReducerEventContext& Context, const UDeleteUniqueStringReducer* Args); + bool InvokeDeleteUniqueStringWithArgs(const FReducerEventContext& Context, const FDeleteUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU128Handler OnDeleteUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU128(const FSpacetimeDBUInt128& N); + + bool InvokeDeleteUniqueU128(const FReducerEventContext& Context, const UDeleteUniqueU128Reducer* Args); + bool InvokeDeleteUniqueU128WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FDeleteUniqueU16Handler OnDeleteUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void DeleteUniqueU16(const uint16 N); + + bool InvokeDeleteUniqueU16(const FReducerEventContext& Context, const UDeleteUniqueU16Reducer* Args); + bool InvokeDeleteUniqueU16WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU256Handler OnDeleteUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU256(const FSpacetimeDBUInt256& N); + + bool InvokeDeleteUniqueU256(const FReducerEventContext& Context, const UDeleteUniqueU256Reducer* Args); + bool InvokeDeleteUniqueU256WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FDeleteUniqueU32Handler OnDeleteUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void DeleteUniqueU32(const uint32 N); + + bool InvokeDeleteUniqueU32(const FReducerEventContext& Context, const UDeleteUniqueU32Reducer* Args); + bool InvokeDeleteUniqueU32WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FDeleteUniqueU64Handler OnDeleteUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void DeleteUniqueU64(const uint64 N); + + bool InvokeDeleteUniqueU64(const FReducerEventContext& Context, const UDeleteUniqueU64Reducer* Args); + bool InvokeDeleteUniqueU64WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueU8Handler, + const FReducerEventContext&, Context, + uint8, N + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueU8Handler OnDeleteUniqueU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueU8(const uint8 N); + + bool InvokeDeleteUniqueU8(const FReducerEventContext& Context, const UDeleteUniqueU8Reducer* Args); + bool InvokeDeleteUniqueU8WithArgs(const FReducerEventContext& Context, const FDeleteUniqueU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FDeleteUniqueUuidHandler, + const FReducerEventContext&, Context, + const FSpacetimeDBUuid&, U + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FDeleteUniqueUuidHandler OnDeleteUniqueUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void DeleteUniqueUuid(const FSpacetimeDBUuid& U); + + bool InvokeDeleteUniqueUuid(const FReducerEventContext& Context, const UDeleteUniqueUuidReducer* Args); + bool InvokeDeleteUniqueUuidWithArgs(const FReducerEventContext& Context, const FDeleteUniqueUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallTimestampHandler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallTimestampHandler OnInsertCallTimestamp; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertCallTimestamp(); + + bool InvokeInsertCallTimestamp(const FReducerEventContext& Context, const UInsertCallTimestampReducer* Args); + bool InvokeInsertCallTimestampWithArgs(const FReducerEventContext& Context, const FInsertCallTimestampArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallUuidV4Handler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallUuidV4Handler OnInsertCallUuidV4; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertCallUuidV4(); + + bool InvokeInsertCallUuidV4(const FReducerEventContext& Context, const UInsertCallUuidV4Reducer* Args); + bool InvokeInsertCallUuidV4WithArgs(const FReducerEventContext& Context, const FInsertCallUuidV4Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( + FInsertCallUuidV7Handler, + const FReducerEventContext&, Context + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertCallUuidV7Handler OnInsertCallUuidV7; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") void InsertCallUuidV7(); @@ -14290,110 +17261,365 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeInsertUniqueIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueStringHandler, + FInsertUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueStringHandler OnInsertUniqueString; + FInsertUniqueOptionBoolHandler OnInsertUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueString(const FString& S, const int32 Data); + void InsertUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args); - bool InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args); + bool InvokeInsertUniqueOptionBool(const FReducerEventContext& Context, const UInsertUniqueOptionBoolReducer* Args); + bool InvokeInsertUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU128Handler, + FInsertUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueU128Handler OnInsertUniqueU128; + FInsertUniqueOptionConnectionIdHandler OnInsertUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void InsertUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args); - bool InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args); + bool InvokeInsertUniqueOptionConnectionId(const FReducerEventContext& Context, const UInsertUniqueOptionConnectionIdReducer* Args); + bool InvokeInsertUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU16Handler, + FInsertUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FInsertUniqueU16Handler OnInsertUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI128Handler OnInsertUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void InsertUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args); - bool InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args); + bool InvokeInsertUniqueOptionI128(const FReducerEventContext& Context, const UInsertUniqueOptionI128Reducer* Args); + bool InvokeInsertUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU256Handler, + FInsertUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FInsertUniqueU256Handler OnInsertUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FInsertUniqueOptionI16Handler OnInsertUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void InsertUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); - bool InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args); - bool InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args); + bool InvokeInsertUniqueOptionI16(const FReducerEventContext& Context, const UInsertUniqueOptionI16Reducer* Args); + bool InvokeInsertUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU32Handler, + FInsertUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N, + const FTestClientOptionalInt256&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FInsertUniqueU32Handler OnInsertUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI256Handler OnInsertUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void InsertUniqueU32(const uint32 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); - bool InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args); - bool InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args); + bool InvokeInsertUniqueOptionI256(const FReducerEventContext& Context, const UInsertUniqueOptionI256Reducer* Args); + bool InvokeInsertUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI256Args& Args); - DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams( - FInsertUniqueU32UpdatePkU32Handler, + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint32, N, - int32, DUnique, - int32, DPk + FTestClientOptionalInt32, N, + int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FInsertUniqueU32UpdatePkU32Handler OnInsertUniqueU32UpdatePkU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI32Handler OnInsertUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); - bool InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args); - bool InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args); + bool InvokeInsertUniqueOptionI32(const FReducerEventContext& Context, const UInsertUniqueOptionI32Reducer* Args); + bool InvokeInsertUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FInsertUniqueU64Handler, + FInsertUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint64, N, + FTestClientOptionalInt64, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FInsertUniqueU64Handler OnInsertUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionI64Handler OnInsertUniqueOptionI64; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void InsertUniqueU64(const uint64 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); - bool InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args); - bool InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args); + bool InvokeInsertUniqueOptionI64(const FReducerEventContext& Context, const UInsertUniqueOptionI64Reducer* Args); + bool InvokeInsertUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionI8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FInsertUniqueOptionI8Handler OnInsertUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void InsertUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeInsertUniqueOptionI8(const FReducerEventContext& Context, const UInsertUniqueOptionI8Reducer* Args); + bool InvokeInsertUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionIdentityHandler OnInsertUniqueOptionIdentity; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); + + bool InvokeInsertUniqueOptionIdentity(const FReducerEventContext& Context, const UInsertUniqueOptionIdentityReducer* Args); + bool InvokeInsertUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionStringHandler OnInsertUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeInsertUniqueOptionString(const FReducerEventContext& Context, const UInsertUniqueOptionStringReducer* Args); + bool InvokeInsertUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU128Handler OnInsertUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeInsertUniqueOptionU128(const FReducerEventContext& Context, const UInsertUniqueOptionU128Reducer* Args); + bool InvokeInsertUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FInsertUniqueOptionU16Handler OnInsertUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void InsertUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeInsertUniqueOptionU16(const FReducerEventContext& Context, const UInsertUniqueOptionU16Reducer* Args); + bool InvokeInsertUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU256Handler OnInsertUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeInsertUniqueOptionU256(const FReducerEventContext& Context, const UInsertUniqueOptionU256Reducer* Args); + bool InvokeInsertUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FInsertUniqueOptionU32Handler OnInsertUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void InsertUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeInsertUniqueOptionU32(const FReducerEventContext& Context, const UInsertUniqueOptionU32Reducer* Args); + bool InvokeInsertUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FInsertUniqueOptionU64Handler OnInsertUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void InsertUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeInsertUniqueOptionU64(const FReducerEventContext& Context, const UInsertUniqueOptionU64Reducer* Args); + bool InvokeInsertUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionU8Handler OnInsertUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeInsertUniqueOptionU8(const FReducerEventContext& Context, const UInsertUniqueOptionU8Reducer* Args); + bool InvokeInsertUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueOptionUuidHandler OnInsertUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeInsertUniqueOptionUuid(const FReducerEventContext& Context, const UInsertUniqueOptionUuidReducer* Args); + bool InvokeInsertUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FInsertUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueStringHandler OnInsertUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueString(const FString& S, const int32 Data); + + bool InvokeInsertUniqueString(const FReducerEventContext& Context, const UInsertUniqueStringReducer* Args); + bool InvokeInsertUniqueStringWithArgs(const FReducerEventContext& Context, const FInsertUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueU128Handler OnInsertUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeInsertUniqueU128(const FReducerEventContext& Context, const UInsertUniqueU128Reducer* Args); + bool InvokeInsertUniqueU128WithArgs(const FReducerEventContext& Context, const FInsertUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FInsertUniqueU16Handler OnInsertUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void InsertUniqueU16(const uint16 N, const int32 Data); + + bool InvokeInsertUniqueU16(const FReducerEventContext& Context, const UInsertUniqueU16Reducer* Args); + bool InvokeInsertUniqueU16WithArgs(const FReducerEventContext& Context, const FInsertUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FInsertUniqueU256Handler OnInsertUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void InsertUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + + bool InvokeInsertUniqueU256(const FReducerEventContext& Context, const UInsertUniqueU256Reducer* Args); + bool InvokeInsertUniqueU256WithArgs(const FReducerEventContext& Context, const FInsertUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FInsertUniqueU32Handler OnInsertUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void InsertUniqueU32(const uint32 N, const int32 Data); + + bool InvokeInsertUniqueU32(const FReducerEventContext& Context, const UInsertUniqueU32Reducer* Args); + bool InvokeInsertUniqueU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams( + FInsertUniqueU32UpdatePkU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, DUnique, + int32, DPk + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FInsertUniqueU32UpdatePkU32Handler OnInsertUniqueU32UpdatePkU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void InsertUniqueU32UpdatePkU32(const uint32 N, const int32 DUnique, const int32 DPk); + + bool InvokeInsertUniqueU32UpdatePkU32(const FReducerEventContext& Context, const UInsertUniqueU32UpdatePkU32Reducer* Args); + bool InvokeInsertUniqueU32UpdatePkU32WithArgs(const FReducerEventContext& Context, const FInsertUniqueU32UpdatePkU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FInsertUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FInsertUniqueU64Handler OnInsertUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void InsertUniqueU64(const uint64 N, const int32 Data); + + bool InvokeInsertUniqueU64(const FReducerEventContext& Context, const UInsertUniqueU64Reducer* Args); + bool InvokeInsertUniqueU64WithArgs(const FReducerEventContext& Context, const FInsertUniqueU64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( FInsertUniqueU8Handler, @@ -15266,123 +18492,378 @@ class TESTCLIENT_API URemoteReducers : public UObject bool InvokeUpdateUniqueIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueIdentityArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueStringHandler, + FUpdateUniqueOptionBoolHandler, const FReducerEventContext&, Context, - const FString&, S, + FTestClientOptionalBool, B, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueStringHandler OnUpdateUniqueString; + FUpdateUniqueOptionBoolHandler OnUpdateUniqueOptionBool; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueString(const FString& S, const int32 Data); + void UpdateUniqueOptionBool(const FTestClientOptionalBool B, const int32 Data); - bool InvokeUpdateUniqueString(const FReducerEventContext& Context, const UUpdateUniqueStringReducer* Args); - bool InvokeUpdateUniqueStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueStringArgs& Args); + bool InvokeUpdateUniqueOptionBool(const FReducerEventContext& Context, const UUpdateUniqueOptionBoolReducer* Args); + bool InvokeUpdateUniqueOptionBoolWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionBoolArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU128Handler, + FUpdateUniqueOptionConnectionIdHandler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt128&, N, + const FTestClientOptionalConnectionId&, A, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU128Handler OnUpdateUniqueU128; + FUpdateUniqueOptionConnectionIdHandler OnUpdateUniqueOptionConnectionId; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + void UpdateUniqueOptionConnectionId(const FTestClientOptionalConnectionId& A, const int32 Data); - bool InvokeUpdateUniqueU128(const FReducerEventContext& Context, const UUpdateUniqueU128Reducer* Args); - bool InvokeUpdateUniqueU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU128Args& Args); + bool InvokeUpdateUniqueOptionConnectionId(const FReducerEventContext& Context, const UUpdateUniqueOptionConnectionIdReducer* Args); + bool InvokeUpdateUniqueOptionConnectionIdWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionConnectionIdArgs& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU16Handler, + FUpdateUniqueOptionI128Handler, const FReducerEventContext&, Context, - uint16, N, + const FTestClientOptionalInt128&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - FUpdateUniqueU16Handler OnUpdateUniqueU16; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI128Handler OnUpdateUniqueOptionI128; - // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible - void UpdateUniqueU16(const uint16 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI128(const FTestClientOptionalInt128& N, const int32 Data); - bool InvokeUpdateUniqueU16(const FReducerEventContext& Context, const UUpdateUniqueU16Reducer* Args); - bool InvokeUpdateUniqueU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU16Args& Args); + bool InvokeUpdateUniqueOptionI128(const FReducerEventContext& Context, const UUpdateUniqueOptionI128Reducer* Args); + bool InvokeUpdateUniqueOptionI128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI128Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU256Handler, + FUpdateUniqueOptionI16Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUInt256&, N, + FTestClientOptionalInt16, N, int32, Data ); - UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU256Handler OnUpdateUniqueU256; + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FUpdateUniqueOptionI16Handler OnUpdateUniqueOptionI16; - UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + void UpdateUniqueOptionI16(const FTestClientOptionalInt16 N, const int32 Data); - bool InvokeUpdateUniqueU256(const FReducerEventContext& Context, const UUpdateUniqueU256Reducer* Args); - bool InvokeUpdateUniqueU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU256Args& Args); + bool InvokeUpdateUniqueOptionI16(const FReducerEventContext& Context, const UUpdateUniqueOptionI16Reducer* Args); + bool InvokeUpdateUniqueOptionI16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI16Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU32Handler, + FUpdateUniqueOptionI256Handler, const FReducerEventContext&, Context, - uint32, N, + const FTestClientOptionalInt256&, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - FUpdateUniqueU32Handler OnUpdateUniqueU32; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI256Handler OnUpdateUniqueOptionI256; - // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible - void UpdateUniqueU32(const uint32 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI256(const FTestClientOptionalInt256& N, const int32 Data); - bool InvokeUpdateUniqueU32(const FReducerEventContext& Context, const UUpdateUniqueU32Reducer* Args); - bool InvokeUpdateUniqueU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU32Args& Args); + bool InvokeUpdateUniqueOptionI256(const FReducerEventContext& Context, const UUpdateUniqueOptionI256Reducer* Args); + bool InvokeUpdateUniqueOptionI256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI256Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU64Handler, + FUpdateUniqueOptionI32Handler, const FReducerEventContext&, Context, - uint64, N, + FTestClientOptionalInt32, N, int32, Data ); - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - FUpdateUniqueU64Handler OnUpdateUniqueU64; + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionI32Handler OnUpdateUniqueOptionI32; - // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible - void UpdateUniqueU64(const uint64 N, const int32 Data); + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionI32(const FTestClientOptionalInt32 N, const int32 Data); - bool InvokeUpdateUniqueU64(const FReducerEventContext& Context, const UUpdateUniqueU64Reducer* Args); - bool InvokeUpdateUniqueU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU64Args& Args); + bool InvokeUpdateUniqueOptionI32(const FReducerEventContext& Context, const UUpdateUniqueOptionI32Reducer* Args); + bool InvokeUpdateUniqueOptionI32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI32Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueU8Handler, + FUpdateUniqueOptionI64Handler, const FReducerEventContext&, Context, - uint8, N, + FTestClientOptionalInt64, N, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueU8Handler OnUpdateUniqueU8; + FUpdateUniqueOptionI64Handler OnUpdateUniqueOptionI64; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueU8(const uint8 N, const int32 Data); + void UpdateUniqueOptionI64(const FTestClientOptionalInt64 N, const int32 Data); - bool InvokeUpdateUniqueU8(const FReducerEventContext& Context, const UUpdateUniqueU8Reducer* Args); - bool InvokeUpdateUniqueU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU8Args& Args); + bool InvokeUpdateUniqueOptionI64(const FReducerEventContext& Context, const UUpdateUniqueOptionI64Reducer* Args); + bool InvokeUpdateUniqueOptionI64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI64Args& Args); DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( - FUpdateUniqueUuidHandler, + FUpdateUniqueOptionI8Handler, const FReducerEventContext&, Context, - const FSpacetimeDBUuid&, U, + FTestClientOptionalInt8, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FUpdateUniqueOptionI8Handler OnUpdateUniqueOptionI8; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + void UpdateUniqueOptionI8(const FTestClientOptionalInt8 N, const int32 Data); + + bool InvokeUpdateUniqueOptionI8(const FReducerEventContext& Context, const UUpdateUniqueOptionI8Reducer* Args); + bool InvokeUpdateUniqueOptionI8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionI8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionIdentityHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalIdentity&, I, int32, Data ); UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") - FUpdateUniqueUuidHandler OnUpdateUniqueUuid; + FUpdateUniqueOptionIdentityHandler OnUpdateUniqueOptionIdentity; UFUNCTION(BlueprintCallable, Category="SpacetimeDB") - void UpdateUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data); + void UpdateUniqueOptionIdentity(const FTestClientOptionalIdentity& I, const int32 Data); - bool InvokeUpdateUniqueUuid(const FReducerEventContext& Context, const UUpdateUniqueUuidReducer* Args); + bool InvokeUpdateUniqueOptionIdentity(const FReducerEventContext& Context, const UUpdateUniqueOptionIdentityReducer* Args); + bool InvokeUpdateUniqueOptionIdentityWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionIdentityArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionStringHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionStringHandler OnUpdateUniqueOptionString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionString(const FTestClientOptionalString& S, const int32 Data); + + bool InvokeUpdateUniqueOptionString(const FReducerEventContext& Context, const UUpdateUniqueOptionStringReducer* Args); + bool InvokeUpdateUniqueOptionStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU128Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU128Handler OnUpdateUniqueOptionU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU128(const FTestClientOptionalUInt128& N, const int32 Data); + + bool InvokeUpdateUniqueOptionU128(const FReducerEventContext& Context, const UUpdateUniqueOptionU128Reducer* Args); + bool InvokeUpdateUniqueOptionU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU16Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FUpdateUniqueOptionU16Handler OnUpdateUniqueOptionU16; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + void UpdateUniqueOptionU16(const FTestClientOptionalUInt16 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU16(const FReducerEventContext& Context, const UUpdateUniqueOptionU16Reducer* Args); + bool InvokeUpdateUniqueOptionU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU256Handler, + const FReducerEventContext&, Context, + const FTestClientOptionalUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU256Handler OnUpdateUniqueOptionU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU256(const FTestClientOptionalUInt256& N, const int32 Data); + + bool InvokeUpdateUniqueOptionU256(const FReducerEventContext& Context, const UUpdateUniqueOptionU256Reducer* Args); + bool InvokeUpdateUniqueOptionU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU32Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FUpdateUniqueOptionU32Handler OnUpdateUniqueOptionU32; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + void UpdateUniqueOptionU32(const FTestClientOptionalUInt32 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU32(const FReducerEventContext& Context, const UUpdateUniqueOptionU32Reducer* Args); + bool InvokeUpdateUniqueOptionU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU64Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FUpdateUniqueOptionU64Handler OnUpdateUniqueOptionU64; + + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + void UpdateUniqueOptionU64(const FTestClientOptionalUInt64 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU64(const FReducerEventContext& Context, const UUpdateUniqueOptionU64Reducer* Args); + bool InvokeUpdateUniqueOptionU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionU8Handler, + const FReducerEventContext&, Context, + FTestClientOptionalUInt8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionU8Handler OnUpdateUniqueOptionU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionU8(const FTestClientOptionalUInt8 N, const int32 Data); + + bool InvokeUpdateUniqueOptionU8(const FReducerEventContext& Context, const UUpdateUniqueOptionU8Reducer* Args); + bool InvokeUpdateUniqueOptionU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueOptionUuidHandler, + const FReducerEventContext&, Context, + const FTestClientOptionalUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueOptionUuidHandler OnUpdateUniqueOptionUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueOptionUuid(const FTestClientOptionalUuid& U, const int32 Data); + + bool InvokeUpdateUniqueOptionUuid(const FReducerEventContext& Context, const UUpdateUniqueOptionUuidReducer* Args); + bool InvokeUpdateUniqueOptionUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueOptionUuidArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueStringHandler, + const FReducerEventContext&, Context, + const FString&, S, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueStringHandler OnUpdateUniqueString; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueString(const FString& S, const int32 Data); + + bool InvokeUpdateUniqueString(const FReducerEventContext& Context, const UUpdateUniqueStringReducer* Args); + bool InvokeUpdateUniqueStringWithArgs(const FReducerEventContext& Context, const FUpdateUniqueStringArgs& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU128Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt128&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU128Handler OnUpdateUniqueU128; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU128(const FSpacetimeDBUInt128& N, const int32 Data); + + bool InvokeUpdateUniqueU128(const FReducerEventContext& Context, const UUpdateUniqueU128Reducer* Args); + bool InvokeUpdateUniqueU128WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU128Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU16Handler, + const FReducerEventContext&, Context, + uint16, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + FUpdateUniqueU16Handler OnUpdateUniqueU16; + + // NOTE: Not exposed to Blueprint because uint16 types are not Blueprint-compatible + void UpdateUniqueU16(const uint16 N, const int32 Data); + + bool InvokeUpdateUniqueU16(const FReducerEventContext& Context, const UUpdateUniqueU16Reducer* Args); + bool InvokeUpdateUniqueU16WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU16Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU256Handler, + const FReducerEventContext&, Context, + const FSpacetimeDBUInt256&, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU256Handler OnUpdateUniqueU256; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU256(const FSpacetimeDBUInt256& N, const int32 Data); + + bool InvokeUpdateUniqueU256(const FReducerEventContext& Context, const UUpdateUniqueU256Reducer* Args); + bool InvokeUpdateUniqueU256WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU256Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU32Handler, + const FReducerEventContext&, Context, + uint32, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + FUpdateUniqueU32Handler OnUpdateUniqueU32; + + // NOTE: Not exposed to Blueprint because uint32 types are not Blueprint-compatible + void UpdateUniqueU32(const uint32 N, const int32 Data); + + bool InvokeUpdateUniqueU32(const FReducerEventContext& Context, const UUpdateUniqueU32Reducer* Args); + bool InvokeUpdateUniqueU32WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU32Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU64Handler, + const FReducerEventContext&, Context, + uint64, N, + int32, Data + ); + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + FUpdateUniqueU64Handler OnUpdateUniqueU64; + + // NOTE: Not exposed to Blueprint because uint64 types are not Blueprint-compatible + void UpdateUniqueU64(const uint64 N, const int32 Data); + + bool InvokeUpdateUniqueU64(const FReducerEventContext& Context, const UUpdateUniqueU64Reducer* Args); + bool InvokeUpdateUniqueU64WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU64Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueU8Handler, + const FReducerEventContext&, Context, + uint8, N, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueU8Handler OnUpdateUniqueU8; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueU8(const uint8 N, const int32 Data); + + bool InvokeUpdateUniqueU8(const FReducerEventContext& Context, const UUpdateUniqueU8Reducer* Args); + bool InvokeUpdateUniqueU8WithArgs(const FReducerEventContext& Context, const FUpdateUniqueU8Args& Args); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FUpdateUniqueUuidHandler, + const FReducerEventContext&, Context, + const FSpacetimeDBUuid&, U, + int32, Data + ); + UPROPERTY(BlueprintAssignable, Category="SpacetimeDB") + FUpdateUniqueUuidHandler OnUpdateUniqueUuid; + + UFUNCTION(BlueprintCallable, Category="SpacetimeDB") + void UpdateUniqueUuid(const FSpacetimeDBUuid& U, const int32 Data); + + bool InvokeUpdateUniqueUuid(const FReducerEventContext& Context, const UUpdateUniqueUuidReducer* Args); bool InvokeUpdateUniqueUuidWithArgs(const FReducerEventContext& Context, const FUpdateUniqueUuidArgs& Args); // Internal error handling @@ -15562,6 +19043,40 @@ struct TESTCLIENT_API FUniqueI8Cols; struct TESTCLIENT_API FUniqueI8IxCols; struct TESTCLIENT_API FUniqueIdentityCols; struct TESTCLIENT_API FUniqueIdentityIxCols; +struct TESTCLIENT_API FUniqueOptionBoolCols; +struct TESTCLIENT_API FUniqueOptionBoolIxCols; +struct TESTCLIENT_API FUniqueOptionConnectionIdCols; +struct TESTCLIENT_API FUniqueOptionConnectionIdIxCols; +struct TESTCLIENT_API FUniqueOptionI128Cols; +struct TESTCLIENT_API FUniqueOptionI128IxCols; +struct TESTCLIENT_API FUniqueOptionI16Cols; +struct TESTCLIENT_API FUniqueOptionI16IxCols; +struct TESTCLIENT_API FUniqueOptionI256Cols; +struct TESTCLIENT_API FUniqueOptionI256IxCols; +struct TESTCLIENT_API FUniqueOptionI32Cols; +struct TESTCLIENT_API FUniqueOptionI32IxCols; +struct TESTCLIENT_API FUniqueOptionI64Cols; +struct TESTCLIENT_API FUniqueOptionI64IxCols; +struct TESTCLIENT_API FUniqueOptionI8Cols; +struct TESTCLIENT_API FUniqueOptionI8IxCols; +struct TESTCLIENT_API FUniqueOptionIdentityCols; +struct TESTCLIENT_API FUniqueOptionIdentityIxCols; +struct TESTCLIENT_API FUniqueOptionStringCols; +struct TESTCLIENT_API FUniqueOptionStringIxCols; +struct TESTCLIENT_API FUniqueOptionU128Cols; +struct TESTCLIENT_API FUniqueOptionU128IxCols; +struct TESTCLIENT_API FUniqueOptionU16Cols; +struct TESTCLIENT_API FUniqueOptionU16IxCols; +struct TESTCLIENT_API FUniqueOptionU256Cols; +struct TESTCLIENT_API FUniqueOptionU256IxCols; +struct TESTCLIENT_API FUniqueOptionU32Cols; +struct TESTCLIENT_API FUniqueOptionU32IxCols; +struct TESTCLIENT_API FUniqueOptionU64Cols; +struct TESTCLIENT_API FUniqueOptionU64IxCols; +struct TESTCLIENT_API FUniqueOptionU8Cols; +struct TESTCLIENT_API FUniqueOptionU8IxCols; +struct TESTCLIENT_API FUniqueOptionUuidCols; +struct TESTCLIENT_API FUniqueOptionUuidIxCols; struct TESTCLIENT_API FUniqueStringCols; struct TESTCLIENT_API FUniqueStringIxCols; struct TESTCLIENT_API FUniqueU128Cols; @@ -17229,581 +20744,615 @@ namespace SpacetimeDB::query_builder struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueStringCols +struct TESTCLIENT_API FUniqueOptionBoolCols { - explicit FUniqueStringCols(const char* TableName) - : S(TableName, "s"), Data(TableName, "data") {} + explicit FUniqueOptionBoolCols(const char* TableName) + : B(TableName, "b"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col S; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col B; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueStringIxCols +struct TESTCLIENT_API FUniqueOptionBoolIxCols { - explicit FUniqueStringIxCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionBoolIxCols(const char* TableName) + : B(TableName, "b") {} - ::SpacetimeDB::query_builder::IxCol S; + ::SpacetimeDB::query_builder::IxCol B; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU128Cols +struct TESTCLIENT_API FUniqueOptionConnectionIdCols { - explicit FUniqueU128Cols(const char* TableName) - : N(TableName, "n"), Data(TableName, "data") {} + explicit FUniqueOptionConnectionIdCols(const char* TableName) + : A(TableName, "a"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col A; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU128IxCols +struct TESTCLIENT_API FUniqueOptionConnectionIdIxCols { - explicit FUniqueU128IxCols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueOptionConnectionIdIxCols(const char* TableName) + : A(TableName, "a") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol A; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU16Cols +struct TESTCLIENT_API FUniqueOptionI128Cols { - explicit FUniqueU16Cols(const char* TableName) + explicit FUniqueOptionI128Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU16IxCols +struct TESTCLIENT_API FUniqueOptionI128IxCols { - explicit FUniqueU16IxCols(const char* TableName) + explicit FUniqueOptionI128IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU256Cols +struct TESTCLIENT_API FUniqueOptionI16Cols { - explicit FUniqueU256Cols(const char* TableName) + explicit FUniqueOptionI16Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU256IxCols +struct TESTCLIENT_API FUniqueOptionI16IxCols { - explicit FUniqueU256IxCols(const char* TableName) + explicit FUniqueOptionI16IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU32Cols +struct TESTCLIENT_API FUniqueOptionI256Cols { - explicit FUniqueU32Cols(const char* TableName) + explicit FUniqueOptionI256Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU32IxCols +struct TESTCLIENT_API FUniqueOptionI256IxCols { - explicit FUniqueU32IxCols(const char* TableName) + explicit FUniqueOptionI256IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU64Cols +struct TESTCLIENT_API FUniqueOptionI32Cols { - explicit FUniqueU64Cols(const char* TableName) + explicit FUniqueOptionI32Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU64IxCols +struct TESTCLIENT_API FUniqueOptionI32IxCols { - explicit FUniqueU64IxCols(const char* TableName) + explicit FUniqueOptionI32IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueU8Cols +struct TESTCLIENT_API FUniqueOptionI64Cols { - explicit FUniqueU8Cols(const char* TableName) + explicit FUniqueOptionI64Cols(const char* TableName) : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col N; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueU8IxCols +struct TESTCLIENT_API FUniqueOptionI64IxCols { - explicit FUniqueU8IxCols(const char* TableName) + explicit FUniqueOptionI64IxCols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol N; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUniqueUuidCols +struct TESTCLIENT_API FUniqueOptionI8Cols { - explicit FUniqueUuidCols(const char* TableName) - : U(TableName, "u"), Data(TableName, "data") {} + explicit FUniqueOptionI8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col U; - ::SpacetimeDB::query_builder::Col Data; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUniqueUuidIxCols +struct TESTCLIENT_API FUniqueOptionI8IxCols { - explicit FUniqueUuidIxCols(const char* TableName) - : U(TableName, "u") {} + explicit FUniqueOptionI8IxCols(const char* TableName) + : N(TableName, "n") {} - ::SpacetimeDB::query_builder::IxCol U; + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FUsersCols +struct TESTCLIENT_API FUniqueOptionIdentityCols { - explicit FUsersCols(const char* TableName) - : Identity(TableName, "identity"), Name(TableName, "name") {} + explicit FUniqueOptionIdentityCols(const char* TableName) + : I(TableName, "i"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col Identity; - ::SpacetimeDB::query_builder::Col Name; + ::SpacetimeDB::query_builder::Col I; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FUsersIxCols +struct TESTCLIENT_API FUniqueOptionIdentityIxCols { - explicit FUsersIxCols(const char* TableName) - : Identity(TableName, "identity") {} + explicit FUniqueOptionIdentityIxCols(const char* TableName) + : I(TableName, "i") {} - ::SpacetimeDB::query_builder::IxCol Identity; + ::SpacetimeDB::query_builder::IxCol I; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecBoolCols +struct TESTCLIENT_API FUniqueOptionStringCols { - explicit FVecBoolCols(const char* TableName) - : B(TableName, "b") {} + explicit FUniqueOptionStringCols(const char* TableName) + : S(TableName, "s"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> B; + ::SpacetimeDB::query_builder::Col S; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecBoolIxCols +struct TESTCLIENT_API FUniqueOptionStringIxCols { - explicit FVecBoolIxCols(const char* TableName) - {} + explicit FUniqueOptionStringIxCols(const char* TableName) + : S(TableName, "s") {} + ::SpacetimeDB::query_builder::IxCol S; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecByteStructCols +struct TESTCLIENT_API FUniqueOptionU128Cols { - explicit FVecByteStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU128Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecByteStructIxCols +struct TESTCLIENT_API FUniqueOptionU128IxCols { - explicit FVecByteStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU128IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecConnectionIdCols +struct TESTCLIENT_API FUniqueOptionU16Cols { - explicit FVecConnectionIdCols(const char* TableName) - : A(TableName, "a") {} + explicit FUniqueOptionU16Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> A; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecConnectionIdIxCols +struct TESTCLIENT_API FUniqueOptionU16IxCols { - explicit FVecConnectionIdIxCols(const char* TableName) - {} + explicit FUniqueOptionU16IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEnumWithPayloadCols +struct TESTCLIENT_API FUniqueOptionU256Cols { - explicit FVecEnumWithPayloadCols(const char* TableName) - : E(TableName, "e") {} + explicit FUniqueOptionU256Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> E; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEnumWithPayloadIxCols +struct TESTCLIENT_API FUniqueOptionU256IxCols { - explicit FVecEnumWithPayloadIxCols(const char* TableName) - {} + explicit FUniqueOptionU256IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEveryPrimitiveStructCols +struct TESTCLIENT_API FUniqueOptionU32Cols { - explicit FVecEveryPrimitiveStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU32Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEveryPrimitiveStructIxCols +struct TESTCLIENT_API FUniqueOptionU32IxCols { - explicit FVecEveryPrimitiveStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU32IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecEveryVecStructCols +struct TESTCLIENT_API FUniqueOptionU64Cols { - explicit FVecEveryVecStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FUniqueOptionU64Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecEveryVecStructIxCols +struct TESTCLIENT_API FUniqueOptionU64IxCols { - explicit FVecEveryVecStructIxCols(const char* TableName) - {} + explicit FUniqueOptionU64IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecF32Cols +struct TESTCLIENT_API FUniqueOptionU8Cols { - explicit FVecF32Cols(const char* TableName) - : F(TableName, "f") {} + explicit FUniqueOptionU8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> F; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecF32IxCols +struct TESTCLIENT_API FUniqueOptionU8IxCols { - explicit FVecF32IxCols(const char* TableName) - {} + explicit FUniqueOptionU8IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecF64Cols +struct TESTCLIENT_API FUniqueOptionUuidCols { - explicit FVecF64Cols(const char* TableName) - : F(TableName, "f") {} + explicit FUniqueOptionUuidCols(const char* TableName) + : U(TableName, "u"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> F; + ::SpacetimeDB::query_builder::Col U; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecF64IxCols +struct TESTCLIENT_API FUniqueOptionUuidIxCols { - explicit FVecF64IxCols(const char* TableName) - {} + explicit FUniqueOptionUuidIxCols(const char* TableName) + : U(TableName, "u") {} + ::SpacetimeDB::query_builder::IxCol U; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI128Cols +struct TESTCLIENT_API FUniqueStringCols { - explicit FVecI128Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueStringCols(const char* TableName) + : S(TableName, "s"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col S; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI128IxCols +struct TESTCLIENT_API FUniqueStringIxCols { - explicit FVecI128IxCols(const char* TableName) - {} + explicit FUniqueStringIxCols(const char* TableName) + : S(TableName, "s") {} + ::SpacetimeDB::query_builder::IxCol S; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI16Cols +struct TESTCLIENT_API FUniqueU128Cols { - explicit FVecI16Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU128Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI16IxCols +struct TESTCLIENT_API FUniqueU128IxCols { - explicit FVecI16IxCols(const char* TableName) - {} + explicit FUniqueU128IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI256Cols +struct TESTCLIENT_API FUniqueU16Cols { - explicit FVecI256Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU16Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI256IxCols +struct TESTCLIENT_API FUniqueU16IxCols { - explicit FVecI256IxCols(const char* TableName) - {} + explicit FUniqueU16IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI32Cols +struct TESTCLIENT_API FUniqueU256Cols { - explicit FVecI32Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU256Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI32IxCols +struct TESTCLIENT_API FUniqueU256IxCols { - explicit FVecI32IxCols(const char* TableName) - {} + explicit FUniqueU256IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI64Cols +struct TESTCLIENT_API FUniqueU32Cols { - explicit FVecI64Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU32Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI64IxCols +struct TESTCLIENT_API FUniqueU32IxCols { - explicit FVecI64IxCols(const char* TableName) - {} + explicit FUniqueU32IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecI8Cols +struct TESTCLIENT_API FUniqueU64Cols { - explicit FVecI8Cols(const char* TableName) - : N(TableName, "n") {} + explicit FUniqueU64Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecI8IxCols +struct TESTCLIENT_API FUniqueU64IxCols { - explicit FVecI8IxCols(const char* TableName) - {} + explicit FUniqueU64IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecIdentityCols +struct TESTCLIENT_API FUniqueU8Cols { - explicit FVecIdentityCols(const char* TableName) - : I(TableName, "i") {} + explicit FUniqueU8Cols(const char* TableName) + : N(TableName, "n"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> I; + ::SpacetimeDB::query_builder::Col N; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecIdentityIxCols +struct TESTCLIENT_API FUniqueU8IxCols { - explicit FVecIdentityIxCols(const char* TableName) - {} + explicit FUniqueU8IxCols(const char* TableName) + : N(TableName, "n") {} + ::SpacetimeDB::query_builder::IxCol N; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecSimpleEnumCols +struct TESTCLIENT_API FUniqueUuidCols { - explicit FVecSimpleEnumCols(const char* TableName) - : E(TableName, "e") {} + explicit FUniqueUuidCols(const char* TableName) + : U(TableName, "u"), Data(TableName, "data") {} - ::SpacetimeDB::query_builder::Col> E; + ::SpacetimeDB::query_builder::Col U; + ::SpacetimeDB::query_builder::Col Data; }; -struct TESTCLIENT_API FVecSimpleEnumIxCols +struct TESTCLIENT_API FUniqueUuidIxCols { - explicit FVecSimpleEnumIxCols(const char* TableName) - {} + explicit FUniqueUuidIxCols(const char* TableName) + : U(TableName, "u") {} + ::SpacetimeDB::query_builder::IxCol U; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecStringCols +struct TESTCLIENT_API FUsersCols { - explicit FVecStringCols(const char* TableName) - : S(TableName, "s") {} + explicit FUsersCols(const char* TableName) + : Identity(TableName, "identity"), Name(TableName, "name") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col Identity; + ::SpacetimeDB::query_builder::Col Name; }; -struct TESTCLIENT_API FVecStringIxCols +struct TESTCLIENT_API FUsersIxCols { - explicit FVecStringIxCols(const char* TableName) - {} + explicit FUsersIxCols(const char* TableName) + : Identity(TableName, "identity") {} + ::SpacetimeDB::query_builder::IxCol Identity; }; namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecTimestampCols +struct TESTCLIENT_API FVecBoolCols { - explicit FVecTimestampCols(const char* TableName) - : T(TableName, "t") {} + explicit FVecBoolCols(const char* TableName) + : B(TableName, "b") {} - ::SpacetimeDB::query_builder::Col> T; + ::SpacetimeDB::query_builder::Col> B; }; -struct TESTCLIENT_API FVecTimestampIxCols +struct TESTCLIENT_API FVecBoolIxCols { - explicit FVecTimestampIxCols(const char* TableName) + explicit FVecBoolIxCols(const char* TableName) {} }; @@ -17811,20 +21360,20 @@ struct TESTCLIENT_API FVecTimestampIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU128Cols +struct TESTCLIENT_API FVecByteStructCols { - explicit FVecU128Cols(const char* TableName) - : N(TableName, "n") {} + explicit FVecByteStructCols(const char* TableName) + : S(TableName, "s") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> S; }; -struct TESTCLIENT_API FVecU128IxCols +struct TESTCLIENT_API FVecByteStructIxCols { - explicit FVecU128IxCols(const char* TableName) + explicit FVecByteStructIxCols(const char* TableName) {} }; @@ -17832,20 +21381,146 @@ struct TESTCLIENT_API FVecU128IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU16Cols +struct TESTCLIENT_API FVecConnectionIdCols { - explicit FVecU16Cols(const char* TableName) + explicit FVecConnectionIdCols(const char* TableName) + : A(TableName, "a") {} + + ::SpacetimeDB::query_builder::Col> A; +}; + +struct TESTCLIENT_API FVecConnectionIdIxCols +{ + explicit FVecConnectionIdIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEnumWithPayloadCols +{ + explicit FVecEnumWithPayloadCols(const char* TableName) + : E(TableName, "e") {} + + ::SpacetimeDB::query_builder::Col> E; +}; + +struct TESTCLIENT_API FVecEnumWithPayloadIxCols +{ + explicit FVecEnumWithPayloadIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEveryPrimitiveStructCols +{ + explicit FVecEveryPrimitiveStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecEveryPrimitiveStructIxCols +{ + explicit FVecEveryPrimitiveStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecEveryVecStructCols +{ + explicit FVecEveryVecStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecEveryVecStructIxCols +{ + explicit FVecEveryVecStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecF32Cols +{ + explicit FVecF32Cols(const char* TableName) + : F(TableName, "f") {} + + ::SpacetimeDB::query_builder::Col> F; +}; + +struct TESTCLIENT_API FVecF32IxCols +{ + explicit FVecF32IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecF64Cols +{ + explicit FVecF64Cols(const char* TableName) + : F(TableName, "f") {} + + ::SpacetimeDB::query_builder::Col> F; +}; + +struct TESTCLIENT_API FVecF64IxCols +{ + explicit FVecF64IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecI128Cols +{ + explicit FVecI128Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU16IxCols +struct TESTCLIENT_API FVecI128IxCols { - explicit FVecU16IxCols(const char* TableName) + explicit FVecI128IxCols(const char* TableName) {} }; @@ -17853,20 +21528,20 @@ struct TESTCLIENT_API FVecU16IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU256Cols +struct TESTCLIENT_API FVecI16Cols { - explicit FVecU256Cols(const char* TableName) + explicit FVecI16Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU256IxCols +struct TESTCLIENT_API FVecI16IxCols { - explicit FVecU256IxCols(const char* TableName) + explicit FVecI16IxCols(const char* TableName) {} }; @@ -17874,20 +21549,20 @@ struct TESTCLIENT_API FVecU256IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU32Cols +struct TESTCLIENT_API FVecI256Cols { - explicit FVecU32Cols(const char* TableName) + explicit FVecI256Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU32IxCols +struct TESTCLIENT_API FVecI256IxCols { - explicit FVecU32IxCols(const char* TableName) + explicit FVecI256IxCols(const char* TableName) {} }; @@ -17895,20 +21570,20 @@ struct TESTCLIENT_API FVecU32IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU64Cols +struct TESTCLIENT_API FVecI32Cols { - explicit FVecU64Cols(const char* TableName) + explicit FVecI32Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU64IxCols +struct TESTCLIENT_API FVecI32IxCols { - explicit FVecU64IxCols(const char* TableName) + explicit FVecI32IxCols(const char* TableName) {} }; @@ -17916,20 +21591,20 @@ struct TESTCLIENT_API FVecU64IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecU8Cols +struct TESTCLIENT_API FVecI64Cols { - explicit FVecU8Cols(const char* TableName) + explicit FVecI64Cols(const char* TableName) : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> N; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecU8IxCols +struct TESTCLIENT_API FVecI64IxCols { - explicit FVecU8IxCols(const char* TableName) + explicit FVecI64IxCols(const char* TableName) {} }; @@ -17937,20 +21612,20 @@ struct TESTCLIENT_API FVecU8IxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecUnitStructCols +struct TESTCLIENT_API FVecI8Cols { - explicit FVecUnitStructCols(const char* TableName) - : S(TableName, "s") {} + explicit FVecI8Cols(const char* TableName) + : N(TableName, "n") {} - ::SpacetimeDB::query_builder::Col> S; + ::SpacetimeDB::query_builder::Col> N; }; -struct TESTCLIENT_API FVecUnitStructIxCols +struct TESTCLIENT_API FVecI8IxCols { - explicit FVecUnitStructIxCols(const char* TableName) + explicit FVecI8IxCols(const char* TableName) {} }; @@ -17958,20 +21633,20 @@ struct TESTCLIENT_API FVecUnitStructIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FVecUuidCols +struct TESTCLIENT_API FVecIdentityCols { - explicit FVecUuidCols(const char* TableName) - : U(TableName, "u") {} + explicit FVecIdentityCols(const char* TableName) + : I(TableName, "i") {} - ::SpacetimeDB::query_builder::Col> U; + ::SpacetimeDB::query_builder::Col> I; }; -struct TESTCLIENT_API FVecUuidIxCols +struct TESTCLIENT_API FVecIdentityIxCols { - explicit FVecUuidIxCols(const char* TableName) + explicit FVecIdentityIxCols(const char* TableName) {} }; @@ -17979,20 +21654,251 @@ struct TESTCLIENT_API FVecUuidIxCols namespace SpacetimeDB::query_builder { template<> - struct CanBeLookupTable> : std::true_type {}; + struct CanBeLookupTable> : std::true_type {}; } -struct TESTCLIENT_API FFrom +struct TESTCLIENT_API FVecSimpleEnumCols { - [[nodiscard]] ::SpacetimeDB::query_builder::Table BtreeU32() const { return ::SpacetimeDB::query_builder::Table("btree_u_32", FBTreeU32Cols("btree_u_32"), FBTreeU32IxCols("btree_u_32")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table IndexedSimpleEnum() const { return ::SpacetimeDB::query_builder::Table("indexed_simple_enum", FIndexedSimpleEnumCols("indexed_simple_enum"), FIndexedSimpleEnumIxCols("indexed_simple_enum")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table LargeTable() const { return ::SpacetimeDB::query_builder::Table("large_table", FLargeTableCols("large_table"), FLargeTableIxCols("large_table")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneBool() const { return ::SpacetimeDB::query_builder::Table("one_bool", FOneBoolCols("one_bool"), FOneBoolIxCols("one_bool")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneByteStruct() const { return ::SpacetimeDB::query_builder::Table("one_byte_struct", FOneByteStructCols("one_byte_struct"), FOneByteStructIxCols("one_byte_struct")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneConnectionId() const { return ::SpacetimeDB::query_builder::Table("one_connection_id", FOneConnectionIdCols("one_connection_id"), FOneConnectionIdIxCols("one_connection_id")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEnumWithPayload() const { return ::SpacetimeDB::query_builder::Table("one_enum_with_payload", FOneEnumWithPayloadCols("one_enum_with_payload"), FOneEnumWithPayloadIxCols("one_enum_with_payload")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryPrimitiveStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_primitive_struct", FOneEveryPrimitiveStructCols("one_every_primitive_struct"), FOneEveryPrimitiveStructIxCols("one_every_primitive_struct")); } - [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryVecStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_vec_struct", FOneEveryVecStructCols("one_every_vec_struct"), FOneEveryVecStructIxCols("one_every_vec_struct")); } + explicit FVecSimpleEnumCols(const char* TableName) + : E(TableName, "e") {} + + ::SpacetimeDB::query_builder::Col> E; +}; + +struct TESTCLIENT_API FVecSimpleEnumIxCols +{ + explicit FVecSimpleEnumIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecStringCols +{ + explicit FVecStringCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecStringIxCols +{ + explicit FVecStringIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecTimestampCols +{ + explicit FVecTimestampCols(const char* TableName) + : T(TableName, "t") {} + + ::SpacetimeDB::query_builder::Col> T; +}; + +struct TESTCLIENT_API FVecTimestampIxCols +{ + explicit FVecTimestampIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU128Cols +{ + explicit FVecU128Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU128IxCols +{ + explicit FVecU128IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU16Cols +{ + explicit FVecU16Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU16IxCols +{ + explicit FVecU16IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU256Cols +{ + explicit FVecU256Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU256IxCols +{ + explicit FVecU256IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU32Cols +{ + explicit FVecU32Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU32IxCols +{ + explicit FVecU32IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU64Cols +{ + explicit FVecU64Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU64IxCols +{ + explicit FVecU64IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecU8Cols +{ + explicit FVecU8Cols(const char* TableName) + : N(TableName, "n") {} + + ::SpacetimeDB::query_builder::Col> N; +}; + +struct TESTCLIENT_API FVecU8IxCols +{ + explicit FVecU8IxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecUnitStructCols +{ + explicit FVecUnitStructCols(const char* TableName) + : S(TableName, "s") {} + + ::SpacetimeDB::query_builder::Col> S; +}; + +struct TESTCLIENT_API FVecUnitStructIxCols +{ + explicit FVecUnitStructIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FVecUuidCols +{ + explicit FVecUuidCols(const char* TableName) + : U(TableName, "u") {} + + ::SpacetimeDB::query_builder::Col> U; +}; + +struct TESTCLIENT_API FVecUuidIxCols +{ + explicit FVecUuidIxCols(const char* TableName) + {} + +}; + +namespace SpacetimeDB::query_builder +{ + template<> + struct CanBeLookupTable> : std::true_type {}; +} + +struct TESTCLIENT_API FFrom +{ + [[nodiscard]] ::SpacetimeDB::query_builder::Table BtreeU32() const { return ::SpacetimeDB::query_builder::Table("btree_u_32", FBTreeU32Cols("btree_u_32"), FBTreeU32IxCols("btree_u_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table IndexedSimpleEnum() const { return ::SpacetimeDB::query_builder::Table("indexed_simple_enum", FIndexedSimpleEnumCols("indexed_simple_enum"), FIndexedSimpleEnumIxCols("indexed_simple_enum")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table LargeTable() const { return ::SpacetimeDB::query_builder::Table("large_table", FLargeTableCols("large_table"), FLargeTableIxCols("large_table")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneBool() const { return ::SpacetimeDB::query_builder::Table("one_bool", FOneBoolCols("one_bool"), FOneBoolIxCols("one_bool")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneByteStruct() const { return ::SpacetimeDB::query_builder::Table("one_byte_struct", FOneByteStructCols("one_byte_struct"), FOneByteStructIxCols("one_byte_struct")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneConnectionId() const { return ::SpacetimeDB::query_builder::Table("one_connection_id", FOneConnectionIdCols("one_connection_id"), FOneConnectionIdIxCols("one_connection_id")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEnumWithPayload() const { return ::SpacetimeDB::query_builder::Table("one_enum_with_payload", FOneEnumWithPayloadCols("one_enum_with_payload"), FOneEnumWithPayloadIxCols("one_enum_with_payload")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryPrimitiveStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_primitive_struct", FOneEveryPrimitiveStructCols("one_every_primitive_struct"), FOneEveryPrimitiveStructIxCols("one_every_primitive_struct")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table OneEveryVecStruct() const { return ::SpacetimeDB::query_builder::Table("one_every_vec_struct", FOneEveryVecStructCols("one_every_vec_struct"), FOneEveryVecStructIxCols("one_every_vec_struct")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneF32() const { return ::SpacetimeDB::query_builder::Table("one_f_32", FOneF32Cols("one_f_32"), FOneF32IxCols("one_f_32")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneF64() const { return ::SpacetimeDB::query_builder::Table("one_f_64", FOneF64Cols("one_f_64"), FOneF64IxCols("one_f_64")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table OneI128() const { return ::SpacetimeDB::query_builder::Table("one_i_128", FOneI128Cols("one_i_128"), FOneI128IxCols("one_i_128")); } @@ -18056,6 +21962,23 @@ struct TESTCLIENT_API FFrom [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueI64() const { return ::SpacetimeDB::query_builder::Table("unique_i_64", FUniqueI64Cols("unique_i_64"), FUniqueI64IxCols("unique_i_64")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueI8() const { return ::SpacetimeDB::query_builder::Table("unique_i_8", FUniqueI8Cols("unique_i_8"), FUniqueI8IxCols("unique_i_8")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueIdentity() const { return ::SpacetimeDB::query_builder::Table("unique_identity", FUniqueIdentityCols("unique_identity"), FUniqueIdentityIxCols("unique_identity")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionBool() const { return ::SpacetimeDB::query_builder::Table("unique_option_bool", FUniqueOptionBoolCols("unique_option_bool"), FUniqueOptionBoolIxCols("unique_option_bool")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionConnectionId() const { return ::SpacetimeDB::query_builder::Table("unique_option_connection_id", FUniqueOptionConnectionIdCols("unique_option_connection_id"), FUniqueOptionConnectionIdIxCols("unique_option_connection_id")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI128() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_128", FUniqueOptionI128Cols("unique_option_i_128"), FUniqueOptionI128IxCols("unique_option_i_128")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI16() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_16", FUniqueOptionI16Cols("unique_option_i_16"), FUniqueOptionI16IxCols("unique_option_i_16")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI256() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_256", FUniqueOptionI256Cols("unique_option_i_256"), FUniqueOptionI256IxCols("unique_option_i_256")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI32() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_32", FUniqueOptionI32Cols("unique_option_i_32"), FUniqueOptionI32IxCols("unique_option_i_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI64() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_64", FUniqueOptionI64Cols("unique_option_i_64"), FUniqueOptionI64IxCols("unique_option_i_64")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionI8() const { return ::SpacetimeDB::query_builder::Table("unique_option_i_8", FUniqueOptionI8Cols("unique_option_i_8"), FUniqueOptionI8IxCols("unique_option_i_8")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionIdentity() const { return ::SpacetimeDB::query_builder::Table("unique_option_identity", FUniqueOptionIdentityCols("unique_option_identity"), FUniqueOptionIdentityIxCols("unique_option_identity")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionString() const { return ::SpacetimeDB::query_builder::Table("unique_option_string", FUniqueOptionStringCols("unique_option_string"), FUniqueOptionStringIxCols("unique_option_string")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU128() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_128", FUniqueOptionU128Cols("unique_option_u_128"), FUniqueOptionU128IxCols("unique_option_u_128")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU16() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_16", FUniqueOptionU16Cols("unique_option_u_16"), FUniqueOptionU16IxCols("unique_option_u_16")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU256() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_256", FUniqueOptionU256Cols("unique_option_u_256"), FUniqueOptionU256IxCols("unique_option_u_256")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU32() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_32", FUniqueOptionU32Cols("unique_option_u_32"), FUniqueOptionU32IxCols("unique_option_u_32")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU64() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_64", FUniqueOptionU64Cols("unique_option_u_64"), FUniqueOptionU64IxCols("unique_option_u_64")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionU8() const { return ::SpacetimeDB::query_builder::Table("unique_option_u_8", FUniqueOptionU8Cols("unique_option_u_8"), FUniqueOptionU8IxCols("unique_option_u_8")); } + [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueOptionUuid() const { return ::SpacetimeDB::query_builder::Table("unique_option_uuid", FUniqueOptionUuidCols("unique_option_uuid"), FUniqueOptionUuidIxCols("unique_option_uuid")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueString() const { return ::SpacetimeDB::query_builder::Table("unique_string", FUniqueStringCols("unique_string"), FUniqueStringIxCols("unique_string")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueU128() const { return ::SpacetimeDB::query_builder::Table("unique_u_128", FUniqueU128Cols("unique_u_128"), FUniqueU128IxCols("unique_u_128")); } [[nodiscard]] ::SpacetimeDB::query_builder::Table UniqueU16() const { return ::SpacetimeDB::query_builder::Table("unique_u_16", FUniqueU16Cols("unique_u_16"), FUniqueU16IxCols("unique_u_16")); } @@ -18172,6 +22095,23 @@ struct TESTCLIENT_API FQueryBuilder Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionBool().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionConnectionId().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI128().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI16().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI256().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI32().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI64().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI8().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionIdentity().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionString().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU128().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU16().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU256().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU32().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU64().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU8().into_sql().c_str()))); + Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionUuid().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueString().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueU128().into_sql().c_str()))); Sql.Add(FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueU16().into_sql().c_str()))); @@ -19100,7 +23040,7 @@ struct TESTCLIENT_API FUniqueIdentityQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueStringQuery +struct TESTCLIENT_API FUniqueOptionBoolQuery { GENERATED_BODY() @@ -19112,7 +23052,7 @@ struct TESTCLIENT_API FUniqueStringQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU128Query +struct TESTCLIENT_API FUniqueOptionConnectionIdQuery { GENERATED_BODY() @@ -19124,7 +23064,7 @@ struct TESTCLIENT_API FUniqueU128Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU16Query +struct TESTCLIENT_API FUniqueOptionI128Query { GENERATED_BODY() @@ -19136,7 +23076,7 @@ struct TESTCLIENT_API FUniqueU16Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU256Query +struct TESTCLIENT_API FUniqueOptionI16Query { GENERATED_BODY() @@ -19148,7 +23088,7 @@ struct TESTCLIENT_API FUniqueU256Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU32Query +struct TESTCLIENT_API FUniqueOptionI256Query { GENERATED_BODY() @@ -19160,7 +23100,7 @@ struct TESTCLIENT_API FUniqueU32Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU64Query +struct TESTCLIENT_API FUniqueOptionI32Query { GENERATED_BODY() @@ -19172,7 +23112,7 @@ struct TESTCLIENT_API FUniqueU64Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueU8Query +struct TESTCLIENT_API FUniqueOptionI64Query { GENERATED_BODY() @@ -19184,7 +23124,7 @@ struct TESTCLIENT_API FUniqueU8Query }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUniqueUuidQuery +struct TESTCLIENT_API FUniqueOptionI8Query { GENERATED_BODY() @@ -19196,7 +23136,7 @@ struct TESTCLIENT_API FUniqueUuidQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FUsersQuery +struct TESTCLIENT_API FUniqueOptionIdentityQuery { GENERATED_BODY() @@ -19208,7 +23148,7 @@ struct TESTCLIENT_API FUsersQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecBoolQuery +struct TESTCLIENT_API FUniqueOptionStringQuery { GENERATED_BODY() @@ -19220,7 +23160,7 @@ struct TESTCLIENT_API FVecBoolQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecByteStructQuery +struct TESTCLIENT_API FUniqueOptionU128Query { GENERATED_BODY() @@ -19232,7 +23172,7 @@ struct TESTCLIENT_API FVecByteStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecConnectionIdQuery +struct TESTCLIENT_API FUniqueOptionU16Query { GENERATED_BODY() @@ -19244,7 +23184,7 @@ struct TESTCLIENT_API FVecConnectionIdQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEnumWithPayloadQuery +struct TESTCLIENT_API FUniqueOptionU256Query { GENERATED_BODY() @@ -19256,7 +23196,7 @@ struct TESTCLIENT_API FVecEnumWithPayloadQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEveryPrimitiveStructQuery +struct TESTCLIENT_API FUniqueOptionU32Query { GENERATED_BODY() @@ -19268,7 +23208,7 @@ struct TESTCLIENT_API FVecEveryPrimitiveStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecEveryVecStructQuery +struct TESTCLIENT_API FUniqueOptionU64Query { GENERATED_BODY() @@ -19280,7 +23220,211 @@ struct TESTCLIENT_API FVecEveryVecStructQuery }; USTRUCT(BlueprintType) -struct TESTCLIENT_API FVecF32Query +struct TESTCLIENT_API FUniqueOptionU8Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionUuidQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueStringQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU128Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU16Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU256Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU32Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU64Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueU8Query +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueUuidQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUsersQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecBoolQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecByteStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecConnectionIdQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEnumWithPayloadQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEveryPrimitiveStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecEveryVecStructQuery +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString Sql; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="SpacetimeDB|Queries") + FString ResultSourceName; +}; + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FVecF32Query { GENERATED_BODY() @@ -19782,32 +23926,597 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable N")) static FBlueprintFloatColumn LargeTableN(const FLargeTableQuery& Query) { - FBlueprintFloatColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; + FBlueprintFloatColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable O")) + static FBlueprintDoubleColumn LargeTableO(const FLargeTableQuery& Query) + { + FBlueprintDoubleColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("o"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable P")) + static FBlueprintStringColumn LargeTableP(const FLargeTableQuery& Query) + { + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("p"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable", meta=(DisplayName="LargeTable Where")) + static FLargeTableQuery LargeTableWhere(FLargeTableQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="From OneBool")) + static FOneBoolQuery FromOneBool() + { + FOneBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_bool"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneBoolQueryToBlueprintQuery(const FOneBoolQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool|Columns", meta=(DisplayName="OneBool B")) + static FBlueprintBoolColumn OneBoolB(const FOneBoolQuery& Query) + { + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="OneBool Where")) + static FOneBoolQuery OneBoolWhere(FOneBoolQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="From OneByteStruct")) + static FOneByteStructQuery FromOneByteStruct() + { + FOneByteStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneByteStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_byte_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneByteStructQueryToBlueprintQuery(const FOneByteStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="OneByteStruct Where")) + static FOneByteStructQuery OneByteStructWhere(FOneByteStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="From OneConnectionId")) + static FOneConnectionIdQuery FromOneConnectionId() + { + FOneConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_connection_id"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneConnectionIdQueryToBlueprintQuery(const FOneConnectionIdQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId|Columns", meta=(DisplayName="OneConnectionId A")) + static FBlueprintConnectionIdColumn OneConnectionIdA(const FOneConnectionIdQuery& Query) + { + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="OneConnectionId Where")) + static FOneConnectionIdQuery OneConnectionIdWhere(FOneConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="From OneEnumWithPayload")) + static FOneEnumWithPayloadQuery FromOneEnumWithPayload() + { + FOneEnumWithPayloadQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEnumWithPayload().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_enum_with_payload"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEnumWithPayloadQueryToBlueprintQuery(const FOneEnumWithPayloadQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="OneEnumWithPayload Where")) + static FOneEnumWithPayloadQuery OneEnumWithPayloadWhere(FOneEnumWithPayloadQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="From OneEveryPrimitiveStruct")) + static FOneEveryPrimitiveStructQuery FromOneEveryPrimitiveStruct() + { + FOneEveryPrimitiveStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryPrimitiveStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_every_primitive_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEveryPrimitiveStructQueryToBlueprintQuery(const FOneEveryPrimitiveStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="OneEveryPrimitiveStruct Where")) + static FOneEveryPrimitiveStructQuery OneEveryPrimitiveStructWhere(FOneEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="From OneEveryVecStruct")) + static FOneEveryVecStructQuery FromOneEveryVecStruct() + { + FOneEveryVecStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryVecStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_every_vec_struct"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneEveryVecStructQueryToBlueprintQuery(const FOneEveryVecStructQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="OneEveryVecStruct Where")) + static FOneEveryVecStructQuery OneEveryVecStructWhere(FOneEveryVecStructQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="From OneF32")) + static FOneF32Query FromOneF32() + { + FOneF32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_f_32"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneF32QueryToBlueprintQuery(const FOneF32Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32|Columns", meta=(DisplayName="OneF32 F")) + static FBlueprintFloatColumn OneF32F(const FOneF32Query& Query) + { + FBlueprintFloatColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("f"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="OneF32 Where")) + static FOneF32Query OneF32Where(FOneF32Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="From OneF64")) + static FOneF64Query FromOneF64() + { + FOneF64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_f_64"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneF64QueryToBlueprintQuery(const FOneF64Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64|Columns", meta=(DisplayName="OneF64 F")) + static FBlueprintDoubleColumn OneF64F(const FOneF64Query& Query) + { + FBlueprintDoubleColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("f"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="OneF64 Where")) + static FOneF64Query OneF64Where(FOneF64Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="From OneI128")) + static FOneI128Query FromOneI128() + { + FOneI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_128"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI128QueryToBlueprintQuery(const FOneI128Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="OneI128 Where")) + static FOneI128Query OneI128Where(FOneI128Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="From OneI16")) + static FOneI16Query FromOneI16() + { + FOneI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_16"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI16QueryToBlueprintQuery(const FOneI16Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="OneI16 Where")) + static FOneI16Query OneI16Where(FOneI16Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="From OneI256")) + static FOneI256Query FromOneI256() + { + FOneI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_256"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI256QueryToBlueprintQuery(const FOneI256Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="OneI256 Where")) + static FOneI256Query OneI256Where(FOneI256Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="From OneI32")) + static FOneI32Query FromOneI32() + { + FOneI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_32"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI32QueryToBlueprintQuery(const FOneI32Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32|Columns", meta=(DisplayName="OneI32 N")) + static FBlueprintInt32Column OneI32N(const FOneI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="OneI32 Where")) + static FOneI32Query OneI32Where(FOneI32Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="From OneI64")) + static FOneI64Query FromOneI64() + { + FOneI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_64"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI64QueryToBlueprintQuery(const FOneI64Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64|Columns", meta=(DisplayName="OneI64 N")) + static FBlueprintInt64Column OneI64N(const FOneI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="OneI64 Where")) + static FOneI64Query OneI64Where(FOneI64Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="From OneI8")) + static FOneI8Query FromOneI8() + { + FOneI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_i_8"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneI8QueryToBlueprintQuery(const FOneI8Query& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="OneI8 Where")) + static FOneI8Query OneI8Where(FOneI8Query Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="From OneIdentity")) + static FOneIdentityQuery FromOneIdentity() + { + FOneIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_identity"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneIdentityQueryToBlueprintQuery(const FOneIdentityQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity|Columns", meta=(DisplayName="OneIdentity I")) + static FBlueprintIdentityColumn OneIdentityI(const FOneIdentityQuery& Query) + { + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="OneIdentity Where")) + static FOneIdentityQuery OneIdentityWhere(FOneIdentityQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="From OneSimpleEnum")) + static FOneSimpleEnumQuery FromOneSimpleEnum() + { + FOneSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_simple_enum"); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneSimpleEnumQueryToBlueprintQuery(const FOneSimpleEnumQuery& Query) + { + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="OneSimpleEnum Where")) + static FOneSimpleEnumQuery OneSimpleEnumWhere(FOneSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + { + if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) + { + return Query; + } + Query.Sql = AppendPredicate(Query.Sql, Predicate.Sql); + return Query; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="From OneString")) + static FOneStringQuery FromOneString() + { + FOneStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneString().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_string"); + return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable O")) - static FBlueprintDoubleColumn LargeTableO(const FLargeTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneStringQueryToBlueprintQuery(const FOneStringQuery& Query) { - FBlueprintDoubleColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("o"); - return Column; + FBlueprintQuery GenericQuery; + GenericQuery.Sql = Query.Sql; + GenericQuery.ResultSourceName = Query.ResultSourceName; + return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable|Columns", meta=(DisplayName="LargeTable P")) - static FBlueprintStringColumn LargeTableP(const FLargeTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString|Columns", meta=(DisplayName="OneString S")) + static FBlueprintStringColumn OneStringS(const FOneStringQuery& Query) { FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("large_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("p"); + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("s"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|LargeTable", meta=(DisplayName="LargeTable Where")) - static FLargeTableQuery LargeTableWhere(FLargeTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="OneString Where")) + static FOneStringQuery OneStringWhere(FOneStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19817,17 +24526,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="From OneBool")) - static FOneBoolQuery FromOneBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="From OneTimestamp")) + static FOneTimestampQuery FromOneTimestamp() { - FOneBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_bool"); + FOneTimestampQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneTimestamp().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_timestamp"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneBoolQueryToBlueprintQuery(const FOneBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneTimestampQueryToBlueprintQuery(const FOneTimestampQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19835,17 +24544,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool|Columns", meta=(DisplayName="OneBool B")) - static FBlueprintBoolColumn OneBoolB(const FOneBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp|Columns", meta=(DisplayName="OneTimestamp T")) + static FBlueprintTimestampColumn OneTimestampT(const FOneTimestampQuery& Query) { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); + FBlueprintTimestampColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_timestamp") : Query.ResultSourceName; + Column.ColumnName = TEXT("t"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneBool", meta=(DisplayName="OneBool Where")) - static FOneBoolQuery OneBoolWhere(FOneBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="OneTimestamp Where")) + static FOneTimestampQuery OneTimestampWhere(FOneTimestampQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19855,17 +24564,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="From OneByteStruct")) - static FOneByteStructQuery FromOneByteStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="From OneU128")) + static FOneU128Query FromOneU128() { - FOneByteStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneByteStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_byte_struct"); + FOneU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneByteStructQueryToBlueprintQuery(const FOneByteStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU128QueryToBlueprintQuery(const FOneU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19873,8 +24582,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneByteStruct", meta=(DisplayName="OneByteStruct Where")) - static FOneByteStructQuery OneByteStructWhere(FOneByteStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="OneU128 Where")) + static FOneU128Query OneU128Where(FOneU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19884,17 +24593,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="From OneConnectionId")) - static FOneConnectionIdQuery FromOneConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="From OneU16")) + static FOneU16Query FromOneU16() { - FOneConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_connection_id"); + FOneU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneConnectionIdQueryToBlueprintQuery(const FOneConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU16QueryToBlueprintQuery(const FOneU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19902,17 +24611,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId|Columns", meta=(DisplayName="OneConnectionId A")) - static FBlueprintConnectionIdColumn OneConnectionIdA(const FOneConnectionIdQuery& Query) - { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneConnectionId", meta=(DisplayName="OneConnectionId Where")) - static FOneConnectionIdQuery OneConnectionIdWhere(FOneConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="OneU16 Where")) + static FOneU16Query OneU16Where(FOneU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19922,17 +24622,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="From OneEnumWithPayload")) - static FOneEnumWithPayloadQuery FromOneEnumWithPayload() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="From OneU256")) + static FOneU256Query FromOneU256() { - FOneEnumWithPayloadQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEnumWithPayload().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_enum_with_payload"); + FOneU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEnumWithPayloadQueryToBlueprintQuery(const FOneEnumWithPayloadQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU256QueryToBlueprintQuery(const FOneU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19940,8 +24640,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEnumWithPayload", meta=(DisplayName="OneEnumWithPayload Where")) - static FOneEnumWithPayloadQuery OneEnumWithPayloadWhere(FOneEnumWithPayloadQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="OneU256 Where")) + static FOneU256Query OneU256Where(FOneU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19951,17 +24651,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="From OneEveryPrimitiveStruct")) - static FOneEveryPrimitiveStructQuery FromOneEveryPrimitiveStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="From OneU32")) + static FOneU32Query FromOneU32() { - FOneEveryPrimitiveStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryPrimitiveStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_every_primitive_struct"); + FOneU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEveryPrimitiveStructQueryToBlueprintQuery(const FOneEveryPrimitiveStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU32QueryToBlueprintQuery(const FOneU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19969,8 +24669,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryPrimitiveStruct", meta=(DisplayName="OneEveryPrimitiveStruct Where")) - static FOneEveryPrimitiveStructQuery OneEveryPrimitiveStructWhere(FOneEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="OneU32 Where")) + static FOneU32Query OneU32Where(FOneU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -19980,17 +24680,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="From OneEveryVecStruct")) - static FOneEveryVecStructQuery FromOneEveryVecStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="From OneU64")) + static FOneU64Query FromOneU64() { - FOneEveryVecStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneEveryVecStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_every_vec_struct"); + FOneU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneEveryVecStructQueryToBlueprintQuery(const FOneEveryVecStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU64QueryToBlueprintQuery(const FOneU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -19998,8 +24698,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneEveryVecStruct", meta=(DisplayName="OneEveryVecStruct Where")) - static FOneEveryVecStructQuery OneEveryVecStructWhere(FOneEveryVecStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="OneU64 Where")) + static FOneU64Query OneU64Where(FOneU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20009,17 +24709,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="From OneF32")) - static FOneF32Query FromOneF32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="From OneU8")) + static FOneU8Query FromOneU8() { - FOneF32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_f_32"); + FOneU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneF32QueryToBlueprintQuery(const FOneF32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneU8QueryToBlueprintQuery(const FOneU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20027,17 +24727,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32|Columns", meta=(DisplayName="OneF32 F")) - static FBlueprintFloatColumn OneF32F(const FOneF32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8|Columns", meta=(DisplayName="OneU8 N")) + static FBlueprintUInt8Column OneU8N(const FOneU8Query& Query) { - FBlueprintFloatColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("f"); + FBlueprintUInt8Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_u_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF32", meta=(DisplayName="OneF32 Where")) - static FOneF32Query OneF32Where(FOneF32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="OneU8 Where")) + static FOneU8Query OneU8Where(FOneU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20047,17 +24747,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="From OneF64")) - static FOneF64Query FromOneF64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="From OneUnitStruct")) + static FOneUnitStructQuery FromOneUnitStruct() { - FOneF64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneF64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_f_64"); + FOneUnitStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUnitStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_unit_struct"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneF64QueryToBlueprintQuery(const FOneF64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneUnitStructQueryToBlueprintQuery(const FOneUnitStructQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20065,17 +24765,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64|Columns", meta=(DisplayName="OneF64 F")) - static FBlueprintDoubleColumn OneF64F(const FOneF64Query& Query) - { - FBlueprintDoubleColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_f_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("f"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneF64", meta=(DisplayName="OneF64 Where")) - static FOneF64Query OneF64Where(FOneF64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="OneUnitStruct Where")) + static FOneUnitStructQuery OneUnitStructWhere(FOneUnitStructQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20085,17 +24776,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="From OneI128")) - static FOneI128Query FromOneI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="From OneUuid")) + static FOneUuidQuery FromOneUuid() { - FOneI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_128"); + FOneUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("one_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI128QueryToBlueprintQuery(const FOneI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OneUuidQueryToBlueprintQuery(const FOneUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20103,8 +24794,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI128", meta=(DisplayName="OneI128 Where")) - static FOneI128Query OneI128Where(FOneI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid|Columns", meta=(DisplayName="OneUuid U")) + static FBlueprintUuidColumn OneUuidU(const FOneUuidQuery& Query) + { + FBlueprintUuidColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_uuid") : Query.ResultSourceName; + Column.ColumnName = TEXT("u"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="OneUuid Where")) + static FOneUuidQuery OneUuidWhere(FOneUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20114,17 +24814,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="From OneI16")) - static FOneI16Query FromOneI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="From OptionEveryPrimitiveStruct")) + static FOptionEveryPrimitiveStructQuery FromOptionEveryPrimitiveStruct() { - FOneI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_16"); + FOptionEveryPrimitiveStructQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionEveryPrimitiveStruct().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_every_primitive_struct"); return Query; } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI16QueryToBlueprintQuery(const FOneI16Query& Query) + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionEveryPrimitiveStructQueryToBlueprintQuery(const FOptionEveryPrimitiveStructQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20132,8 +24832,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI16", meta=(DisplayName="OneI16 Where")) - static FOneI16Query OneI16Where(FOneI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="OptionEveryPrimitiveStruct Where")) + static FOptionEveryPrimitiveStructQuery OptionEveryPrimitiveStructWhere(FOptionEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20143,17 +24843,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="From OneI256")) - static FOneI256Query FromOneI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="From OptionI32")) + static FOptionI32Query FromOptionI32() { - FOneI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_256"); + FOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI256QueryToBlueprintQuery(const FOneI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionI32QueryToBlueprintQuery(const FOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20161,8 +24861,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI256", meta=(DisplayName="OneI256 Where")) - static FOneI256Query OneI256Where(FOneI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="OptionI32 Where")) + static FOptionI32Query OptionI32Where(FOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20172,17 +24872,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="From OneI32")) - static FOneI32Query FromOneI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="From OptionIdentity")) + static FOptionIdentityQuery FromOptionIdentity() { - FOneI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_32"); + FOptionIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI32QueryToBlueprintQuery(const FOneI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionIdentityQueryToBlueprintQuery(const FOptionIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20190,17 +24890,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32|Columns", meta=(DisplayName="OneI32 N")) - static FBlueprintInt32Column OneI32N(const FOneI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI32", meta=(DisplayName="OneI32 Where")) - static FOneI32Query OneI32Where(FOneI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="OptionIdentity Where")) + static FOptionIdentityQuery OptionIdentityWhere(FOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20210,17 +24901,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="From OneI64")) - static FOneI64Query FromOneI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="From OptionSimpleEnum")) + static FOptionSimpleEnumQuery FromOptionSimpleEnum() { - FOneI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_64"); + FOptionSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_simple_enum"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI64QueryToBlueprintQuery(const FOneI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionSimpleEnumQueryToBlueprintQuery(const FOptionSimpleEnumQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20228,17 +24919,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64|Columns", meta=(DisplayName="OneI64 N")) - static FBlueprintInt64Column OneI64N(const FOneI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI64", meta=(DisplayName="OneI64 Where")) - static FOneI64Query OneI64Where(FOneI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="OptionSimpleEnum Where")) + static FOptionSimpleEnumQuery OptionSimpleEnumWhere(FOptionSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20248,17 +24930,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="From OneI8")) - static FOneI8Query FromOneI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="From OptionString")) + static FOptionStringQuery FromOptionString() { - FOneI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_i_8"); + FOptionStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionString().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneI8QueryToBlueprintQuery(const FOneI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionStringQueryToBlueprintQuery(const FOptionStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20266,8 +24948,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneI8", meta=(DisplayName="OneI8 Where")) - static FOneI8Query OneI8Where(FOneI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="OptionString Where")) + static FOptionStringQuery OptionStringWhere(FOptionStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20277,17 +24959,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="From OneIdentity")) - static FOneIdentityQuery FromOneIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="From OptionUuid")) + static FOptionUuidQuery FromOptionUuid() { - FOneIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_identity"); + FOptionUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneIdentityQueryToBlueprintQuery(const FOneIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionUuidQueryToBlueprintQuery(const FOptionUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20295,17 +24977,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity|Columns", meta=(DisplayName="OneIdentity I")) - static FBlueprintIdentityColumn OneIdentityI(const FOneIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneIdentity", meta=(DisplayName="OneIdentity Where")) - static FOneIdentityQuery OneIdentityWhere(FOneIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="OptionUuid Where")) + static FOptionUuidQuery OptionUuidWhere(FOptionUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20315,17 +24988,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="From OneSimpleEnum")) - static FOneSimpleEnumQuery FromOneSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="From OptionVecOptionI32")) + static FOptionVecOptionI32Query FromOptionVecOptionI32() { - FOneSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_simple_enum"); + FOptionVecOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionVecOptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("option_vec_option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneSimpleEnumQueryToBlueprintQuery(const FOneSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_OptionVecOptionI32QueryToBlueprintQuery(const FOptionVecOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20333,8 +25006,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneSimpleEnum", meta=(DisplayName="OneSimpleEnum Where")) - static FOneSimpleEnumQuery OneSimpleEnumWhere(FOneSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="OptionVecOptionI32 Where")) + static FOptionVecOptionI32Query OptionVecOptionI32Where(FOptionVecOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20344,17 +25017,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="From OneString")) - static FOneStringQuery FromOneString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="From PkBool")) + static FPkBoolQuery FromPkBool() { - FOneStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneString().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_string"); + FPkBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneStringQueryToBlueprintQuery(const FOneStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkBoolQueryToBlueprintQuery(const FPkBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20362,17 +25035,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString|Columns", meta=(DisplayName="OneString S")) - static FBlueprintStringColumn OneStringS(const FOneStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool B")) + static FBlueprintBoolColumn PkBoolB(const FPkBoolQuery& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_string") : Query.ResultSourceName; - Column.ColumnName = TEXT("s"); + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneString", meta=(DisplayName="OneString Where")) - static FOneStringQuery OneStringWhere(FOneStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool Data")) + static FBlueprintInt32Column PkBoolData(const FPkBoolQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="PkBool Where")) + static FPkBoolQuery PkBoolWhere(FPkBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20382,17 +25064,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="From OneTimestamp")) - static FOneTimestampQuery FromOneTimestamp() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="From PkConnectionId")) + static FPkConnectionIdQuery FromPkConnectionId() { - FOneTimestampQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneTimestamp().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_timestamp"); + FPkConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneTimestampQueryToBlueprintQuery(const FOneTimestampQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkConnectionIdQueryToBlueprintQuery(const FPkConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20400,17 +25082,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp|Columns", meta=(DisplayName="OneTimestamp T")) - static FBlueprintTimestampColumn OneTimestampT(const FOneTimestampQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId A")) + static FBlueprintConnectionIdColumn PkConnectionIdA(const FPkConnectionIdQuery& Query) { - FBlueprintTimestampColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_timestamp") : Query.ResultSourceName; - Column.ColumnName = TEXT("t"); + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneTimestamp", meta=(DisplayName="OneTimestamp Where")) - static FOneTimestampQuery OneTimestampWhere(FOneTimestampQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId Data")) + static FBlueprintInt32Column PkConnectionIdData(const FPkConnectionIdQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="PkConnectionId Where")) + static FPkConnectionIdQuery PkConnectionIdWhere(FPkConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20420,17 +25111,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="From OneU128")) - static FOneU128Query FromOneU128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="From PkI128")) + static FPkI128Query FromPkI128() { - FOneU128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU128().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_128"); + FPkI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU128QueryToBlueprintQuery(const FOneU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI128QueryToBlueprintQuery(const FPkI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20438,8 +25129,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU128", meta=(DisplayName="OneU128 Where")) - static FOneU128Query OneU128Where(FOneU128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128|Columns", meta=(DisplayName="PkI128 Data")) + static FBlueprintInt32Column PkI128Data(const FPkI128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="PkI128 Where")) + static FPkI128Query PkI128Where(FPkI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20449,17 +25149,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="From OneU16")) - static FOneU16Query FromOneU16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="From PkI16")) + static FPkI16Query FromPkI16() { - FOneU16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU16().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_16"); + FPkI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_16"); return Query; } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU16QueryToBlueprintQuery(const FOneU16Query& Query) + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI16QueryToBlueprintQuery(const FPkI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20467,8 +25167,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU16", meta=(DisplayName="OneU16 Where")) - static FOneU16Query OneU16Where(FOneU16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16|Columns", meta=(DisplayName="PkI16 Data")) + static FBlueprintInt32Column PkI16Data(const FPkI16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="PkI16 Where")) + static FPkI16Query PkI16Where(FPkI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20478,17 +25187,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="From OneU256")) - static FOneU256Query FromOneU256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="From PkI256")) + static FPkI256Query FromPkI256() { - FOneU256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU256().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_256"); + FPkI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU256QueryToBlueprintQuery(const FOneU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI256QueryToBlueprintQuery(const FPkI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20496,8 +25205,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU256", meta=(DisplayName="OneU256 Where")) - static FOneU256Query OneU256Where(FOneU256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256|Columns", meta=(DisplayName="PkI256 Data")) + static FBlueprintInt32Column PkI256Data(const FPkI256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="PkI256 Where")) + static FPkI256Query PkI256Where(FPkI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20507,17 +25225,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="From OneU32")) - static FOneU32Query FromOneU32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="From PkI32")) + static FPkI32Query FromPkI32() { - FOneU32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU32().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_32"); + FPkI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU32QueryToBlueprintQuery(const FOneU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI32QueryToBlueprintQuery(const FPkI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20525,8 +25243,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU32", meta=(DisplayName="OneU32 Where")) - static FOneU32Query OneU32Where(FOneU32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 N")) + static FBlueprintInt32Column PkI32N(const FPkI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 Data")) + static FBlueprintInt32Column PkI32Data(const FPkI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="PkI32 Where")) + static FPkI32Query PkI32Where(FPkI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20536,17 +25272,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="From OneU64")) - static FOneU64Query FromOneU64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="From PkI64")) + static FPkI64Query FromPkI64() { - FOneU64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU64().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_64"); + FPkI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU64QueryToBlueprintQuery(const FOneU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI64QueryToBlueprintQuery(const FPkI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20554,8 +25290,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU64", meta=(DisplayName="OneU64 Where")) - static FOneU64Query OneU64Where(FOneU64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 N")) + static FBlueprintInt64Column PkI64N(const FPkI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 Data")) + static FBlueprintInt32Column PkI64Data(const FPkI64Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="PkI64 Where")) + static FPkI64Query PkI64Where(FPkI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20565,17 +25319,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="From OneU8")) - static FOneU8Query FromOneU8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="From PkI8")) + static FPkI8Query FromPkI8() { - FOneU8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneU8().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_u_8"); + FPkI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneU8QueryToBlueprintQuery(const FOneU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkI8QueryToBlueprintQuery(const FPkI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20583,17 +25337,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8|Columns", meta=(DisplayName="OneU8 N")) - static FBlueprintUInt8Column OneU8N(const FOneU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8|Columns", meta=(DisplayName="PkI8 Data")) + static FBlueprintInt32Column PkI8Data(const FPkI8Query& Query) { - FBlueprintUInt8Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_u_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneU8", meta=(DisplayName="OneU8 Where")) - static FOneU8Query OneU8Where(FOneU8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="PkI8 Where")) + static FPkI8Query PkI8Where(FPkI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20603,17 +25357,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="From OneUnitStruct")) - static FOneUnitStructQuery FromOneUnitStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="From PkIdentity")) + static FPkIdentityQuery FromPkIdentity() { - FOneUnitStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUnitStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_unit_struct"); + FPkIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneUnitStructQueryToBlueprintQuery(const FOneUnitStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkIdentityQueryToBlueprintQuery(const FPkIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20621,8 +25375,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUnitStruct", meta=(DisplayName="OneUnitStruct Where")) - static FOneUnitStructQuery OneUnitStructWhere(FOneUnitStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity I")) + static FBlueprintIdentityColumn PkIdentityI(const FPkIdentityQuery& Query) + { + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity Data")) + static FBlueprintInt32Column PkIdentityData(const FPkIdentityQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="PkIdentity Where")) + static FPkIdentityQuery PkIdentityWhere(FPkIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20632,17 +25404,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="From OneUuid")) - static FOneUuidQuery FromOneUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="From PkSimpleEnum")) + static FPkSimpleEnumQuery FromPkSimpleEnum() { - FOneUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OneUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("one_uuid"); + FPkSimpleEnumQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkSimpleEnum().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_simple_enum"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OneUuidQueryToBlueprintQuery(const FOneUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkSimpleEnumQueryToBlueprintQuery(const FPkSimpleEnumQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20650,17 +25422,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid|Columns", meta=(DisplayName="OneUuid U")) - static FBlueprintUuidColumn OneUuidU(const FOneUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum|Columns", meta=(DisplayName="PkSimpleEnum Data")) + static FBlueprintInt32Column PkSimpleEnumData(const FPkSimpleEnumQuery& Query) { - FBlueprintUuidColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("one_uuid") : Query.ResultSourceName; - Column.ColumnName = TEXT("u"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_simple_enum") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OneUuid", meta=(DisplayName="OneUuid Where")) - static FOneUuidQuery OneUuidWhere(FOneUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="PkSimpleEnum Where")) + static FPkSimpleEnumQuery PkSimpleEnumWhere(FPkSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20670,17 +25442,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="From OptionEveryPrimitiveStruct")) - static FOptionEveryPrimitiveStructQuery FromOptionEveryPrimitiveStruct() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="From PkString")) + static FPkStringQuery FromPkString() { - FOptionEveryPrimitiveStructQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionEveryPrimitiveStruct().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_every_primitive_struct"); + FPkStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkString().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionEveryPrimitiveStructQueryToBlueprintQuery(const FOptionEveryPrimitiveStructQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkStringQueryToBlueprintQuery(const FPkStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20688,8 +25460,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionEveryPrimitiveStruct", meta=(DisplayName="OptionEveryPrimitiveStruct Where")) - static FOptionEveryPrimitiveStructQuery OptionEveryPrimitiveStructWhere(FOptionEveryPrimitiveStructQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString S")) + static FBlueprintStringColumn PkStringS(const FPkStringQuery& Query) + { + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("s"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString Data")) + static FBlueprintInt32Column PkStringData(const FPkStringQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="PkString Where")) + static FPkStringQuery PkStringWhere(FPkStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20699,17 +25489,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="From OptionI32")) - static FOptionI32Query FromOptionI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="From PkU128")) + static FPkU128Query FromPkU128() { - FOptionI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_i_32"); + FPkU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionI32QueryToBlueprintQuery(const FOptionI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU128QueryToBlueprintQuery(const FPkU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20717,8 +25507,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionI32", meta=(DisplayName="OptionI32 Where")) - static FOptionI32Query OptionI32Where(FOptionI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128|Columns", meta=(DisplayName="PkU128 Data")) + static FBlueprintInt32Column PkU128Data(const FPkU128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="PkU128 Where")) + static FPkU128Query PkU128Where(FPkU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20728,17 +25527,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="From OptionIdentity")) - static FOptionIdentityQuery FromOptionIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="From PkU16")) + static FPkU16Query FromPkU16() { - FOptionIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_identity"); + FPkU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionIdentityQueryToBlueprintQuery(const FOptionIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU16QueryToBlueprintQuery(const FPkU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20746,8 +25545,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionIdentity", meta=(DisplayName="OptionIdentity Where")) - static FOptionIdentityQuery OptionIdentityWhere(FOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16|Columns", meta=(DisplayName="PkU16 Data")) + static FBlueprintInt32Column PkU16Data(const FPkU16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="PkU16 Where")) + static FPkU16Query PkU16Where(FPkU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20757,17 +25565,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="From OptionSimpleEnum")) - static FOptionSimpleEnumQuery FromOptionSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="From PkU256")) + static FPkU256Query FromPkU256() { - FOptionSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_simple_enum"); + FPkU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionSimpleEnumQueryToBlueprintQuery(const FOptionSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU256QueryToBlueprintQuery(const FPkU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20775,8 +25583,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionSimpleEnum", meta=(DisplayName="OptionSimpleEnum Where")) - static FOptionSimpleEnumQuery OptionSimpleEnumWhere(FOptionSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256|Columns", meta=(DisplayName="PkU256 Data")) + static FBlueprintInt32Column PkU256Data(const FPkU256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="PkU256 Where")) + static FPkU256Query PkU256Where(FPkU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20786,17 +25603,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="From OptionString")) - static FOptionStringQuery FromOptionString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="From PkU32")) + static FPkU32Query FromPkU32() { - FOptionStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionString().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_string"); + FPkU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionStringQueryToBlueprintQuery(const FOptionStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU32QueryToBlueprintQuery(const FPkU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20804,8 +25621,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionString", meta=(DisplayName="OptionString Where")) - static FOptionStringQuery OptionStringWhere(FOptionStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32|Columns", meta=(DisplayName="PkU32 Data")) + static FBlueprintInt32Column PkU32Data(const FPkU32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="PkU32 Where")) + static FPkU32Query PkU32Where(FPkU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20815,17 +25641,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="From OptionUuid")) - static FOptionUuidQuery FromOptionUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="From PkU32Two")) + static FPkU32TwoQuery FromPkU32Two() { - FOptionUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_uuid"); + FPkU32TwoQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32Two().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_32_two"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionUuidQueryToBlueprintQuery(const FOptionUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU32TwoQueryToBlueprintQuery(const FPkU32TwoQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20833,8 +25659,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionUuid", meta=(DisplayName="OptionUuid Where")) - static FOptionUuidQuery OptionUuidWhere(FOptionUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two|Columns", meta=(DisplayName="PkU32Two Data")) + static FBlueprintInt32Column PkU32TwoData(const FPkU32TwoQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32_two") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="PkU32Two Where")) + static FPkU32TwoQuery PkU32TwoWhere(FPkU32TwoQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20844,17 +25679,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="From OptionVecOptionI32")) - static FOptionVecOptionI32Query FromOptionVecOptionI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="From PkU64")) + static FPkU64Query FromPkU64() { - FOptionVecOptionI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.OptionVecOptionI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("option_vec_option_i_32"); + FPkU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_OptionVecOptionI32QueryToBlueprintQuery(const FOptionVecOptionI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU64QueryToBlueprintQuery(const FPkU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20862,8 +25697,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|OptionVecOptionI32", meta=(DisplayName="OptionVecOptionI32 Where")) - static FOptionVecOptionI32Query OptionVecOptionI32Where(FOptionVecOptionI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64|Columns", meta=(DisplayName="PkU64 Data")) + static FBlueprintInt32Column PkU64Data(const FPkU64Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="PkU64 Where")) + static FPkU64Query PkU64Where(FPkU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20873,17 +25717,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="From PkBool")) - static FPkBoolQuery FromPkBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="From PkU8")) + static FPkU8Query FromPkU8() { - FPkBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_bool"); + FPkU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkBoolQueryToBlueprintQuery(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkU8QueryToBlueprintQuery(const FPkU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20891,26 +25735,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool B")) - static FBlueprintBoolColumn PkBoolB(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 N")) + static FBlueprintUInt8Column PkU8N(const FPkU8Query& Query) { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); + FBlueprintUInt8Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool|Columns", meta=(DisplayName="PkBool Data")) - static FBlueprintInt32Column PkBoolData(const FPkBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 Data")) + static FBlueprintInt32Column PkU8Data(const FPkU8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_bool") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkBool", meta=(DisplayName="PkBool Where")) - static FPkBoolQuery PkBoolWhere(FPkBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="PkU8 Where")) + static FPkU8Query PkU8Where(FPkU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20920,17 +25764,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="From PkConnectionId")) - static FPkConnectionIdQuery FromPkConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="From PkUuid")) + static FPkUuidQuery FromPkUuid() { - FPkConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_connection_id"); + FPkUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("pk_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkConnectionIdQueryToBlueprintQuery(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_PkUuidQueryToBlueprintQuery(const FPkUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20938,26 +25782,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId A")) - static FBlueprintConnectionIdColumn PkConnectionIdA(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid U")) + static FBlueprintUuidColumn PkUuidU(const FPkUuidQuery& Query) { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); + FBlueprintUuidColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; + Column.ColumnName = TEXT("u"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId|Columns", meta=(DisplayName="PkConnectionId Data")) - static FBlueprintInt32Column PkConnectionIdData(const FPkConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid Data")) + static FBlueprintInt32Column PkUuidData(const FPkUuidQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_connection_id") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkConnectionId", meta=(DisplayName="PkConnectionId Where")) - static FPkConnectionIdQuery PkConnectionIdWhere(FPkConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="PkUuid Where")) + static FPkUuidQuery PkUuidWhere(FPkUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -20967,17 +25811,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="From PkI128")) - static FPkI128Query FromPkI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="From ResultEveryPrimitiveStructString")) + static FResultEveryPrimitiveStructStringQuery FromResultEveryPrimitiveStructString() { - FPkI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_128"); + FResultEveryPrimitiveStructStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultEveryPrimitiveStructString().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_every_primitive_struct_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI128QueryToBlueprintQuery(const FPkI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultEveryPrimitiveStructStringQueryToBlueprintQuery(const FResultEveryPrimitiveStructStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -20985,17 +25829,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128|Columns", meta=(DisplayName="PkI128 Data")) - static FBlueprintInt32Column PkI128Data(const FPkI128Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_128") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI128", meta=(DisplayName="PkI128 Where")) - static FPkI128Query PkI128Where(FPkI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="ResultEveryPrimitiveStructString Where")) + static FResultEveryPrimitiveStructStringQuery ResultEveryPrimitiveStructStringWhere(FResultEveryPrimitiveStructStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21005,17 +25840,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="From PkI16")) - static FPkI16Query FromPkI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="From ResultI32String")) + static FResultI32StringQuery FromResultI32String() { - FPkI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_16"); + FResultI32StringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultI32String().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_i_32_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI16QueryToBlueprintQuery(const FPkI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultI32StringQueryToBlueprintQuery(const FResultI32StringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21023,17 +25858,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16|Columns", meta=(DisplayName="PkI16 Data")) - static FBlueprintInt32Column PkI16Data(const FPkI16Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_16") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI16", meta=(DisplayName="PkI16 Where")) - static FPkI16Query PkI16Where(FPkI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="ResultI32String Where")) + static FResultI32StringQuery ResultI32StringWhere(FResultI32StringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21043,17 +25869,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="From PkI256")) - static FPkI256Query FromPkI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="From ResultIdentityString")) + static FResultIdentityStringQuery FromResultIdentityString() { - FPkI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_256"); + FResultIdentityStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultIdentityString().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_identity_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI256QueryToBlueprintQuery(const FPkI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultIdentityStringQueryToBlueprintQuery(const FResultIdentityStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21061,17 +25887,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256|Columns", meta=(DisplayName="PkI256 Data")) - static FBlueprintInt32Column PkI256Data(const FPkI256Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_256") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI256", meta=(DisplayName="PkI256 Where")) - static FPkI256Query PkI256Where(FPkI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="ResultIdentityString Where")) + static FResultIdentityStringQuery ResultIdentityStringWhere(FResultIdentityStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21081,17 +25898,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="From PkI32")) - static FPkI32Query FromPkI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="From ResultSimpleEnumI32")) + static FResultSimpleEnumI32Query FromResultSimpleEnumI32() { - FPkI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_32"); + FResultSimpleEnumI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultSimpleEnumI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_simple_enum_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI32QueryToBlueprintQuery(const FPkI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultSimpleEnumI32QueryToBlueprintQuery(const FResultSimpleEnumI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21099,26 +25916,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 N")) - static FBlueprintInt32Column PkI32N(const FPkI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32|Columns", meta=(DisplayName="PkI32 Data")) - static FBlueprintInt32Column PkI32Data(const FPkI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI32", meta=(DisplayName="PkI32 Where")) - static FPkI32Query PkI32Where(FPkI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="ResultSimpleEnumI32 Where")) + static FResultSimpleEnumI32Query ResultSimpleEnumI32Where(FResultSimpleEnumI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21128,17 +25927,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="From PkI64")) - static FPkI64Query FromPkI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="From ResultStringI32")) + static FResultStringI32Query FromResultStringI32() { - FPkI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_64"); + FResultStringI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultStringI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_string_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI64QueryToBlueprintQuery(const FPkI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultStringI32QueryToBlueprintQuery(const FResultStringI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21146,26 +25945,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 N")) - static FBlueprintInt64Column PkI64N(const FPkI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64|Columns", meta=(DisplayName="PkI64 Data")) - static FBlueprintInt32Column PkI64Data(const FPkI64Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI64", meta=(DisplayName="PkI64 Where")) - static FPkI64Query PkI64Where(FPkI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="ResultStringI32 Where")) + static FResultStringI32Query ResultStringI32Where(FResultStringI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21175,17 +25956,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="From PkI8")) - static FPkI8Query FromPkI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="From ResultVecI32String")) + static FResultVecI32StringQuery FromResultVecI32String() { - FPkI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_i_8"); + FResultVecI32StringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultVecI32String().into_sql().c_str())); + Query.ResultSourceName = TEXT("result_vec_i_32_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkI8QueryToBlueprintQuery(const FPkI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ResultVecI32StringQueryToBlueprintQuery(const FResultVecI32StringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21193,17 +25974,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8|Columns", meta=(DisplayName="PkI8 Data")) - static FBlueprintInt32Column PkI8Data(const FPkI8Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_i_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkI8", meta=(DisplayName="PkI8 Where")) - static FPkI8Query PkI8Where(FPkI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="ResultVecI32String Where")) + static FResultVecI32StringQuery ResultVecI32StringWhere(FResultVecI32StringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21213,17 +25985,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="From PkIdentity")) - static FPkIdentityQuery FromPkIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="From ScheduledTable")) + static FScheduledTableQuery FromScheduledTable() { - FPkIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_identity"); + FScheduledTableQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ScheduledTable().into_sql().c_str())); + Query.ResultSourceName = TEXT("scheduled_table"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkIdentityQueryToBlueprintQuery(const FPkIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_ScheduledTableQueryToBlueprintQuery(const FScheduledTableQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21231,26 +26003,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity I")) - static FBlueprintIdentityColumn PkIdentityI(const FPkIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity|Columns", meta=(DisplayName="PkIdentity Data")) - static FBlueprintInt32Column PkIdentityData(const FPkIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable|Columns", meta=(DisplayName="ScheduledTable Text")) + static FBlueprintStringColumn ScheduledTableText(const FScheduledTableQuery& Query) { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); + FBlueprintStringColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("scheduled_table") : Query.ResultSourceName; + Column.ColumnName = TEXT("text"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkIdentity", meta=(DisplayName="PkIdentity Where")) - static FPkIdentityQuery PkIdentityWhere(FPkIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="ScheduledTable Where")) + static FScheduledTableQuery ScheduledTableWhere(FScheduledTableQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21260,17 +26023,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="From PkSimpleEnum")) - static FPkSimpleEnumQuery FromPkSimpleEnum() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="From TableHoldsTable")) + static FTableHoldsTableQuery FromTableHoldsTable() { - FPkSimpleEnumQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkSimpleEnum().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_simple_enum"); + FTableHoldsTableQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.TableHoldsTable().into_sql().c_str())); + Query.ResultSourceName = TEXT("table_holds_table"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkSimpleEnumQueryToBlueprintQuery(const FPkSimpleEnumQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_TableHoldsTableQueryToBlueprintQuery(const FTableHoldsTableQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21278,17 +26041,8 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum|Columns", meta=(DisplayName="PkSimpleEnum Data")) - static FBlueprintInt32Column PkSimpleEnumData(const FPkSimpleEnumQuery& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_simple_enum") : Query.ResultSourceName; - Column.ColumnName = TEXT("data"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkSimpleEnum", meta=(DisplayName="PkSimpleEnum Where")) - static FPkSimpleEnumQuery PkSimpleEnumWhere(FPkSimpleEnumQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="TableHoldsTable Where")) + static FTableHoldsTableQuery TableHoldsTableWhere(FTableHoldsTableQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21298,17 +26052,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="From PkString")) - static FPkStringQuery FromPkString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="From UniqueBool")) + static FUniqueBoolQuery FromUniqueBool() { - FPkStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkString().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_string"); + FUniqueBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkStringQueryToBlueprintQuery(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueBoolQueryToBlueprintQuery(const FUniqueBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21316,26 +26070,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString S")) - static FBlueprintStringColumn PkStringS(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool B")) + static FBlueprintBoolColumn UniqueBoolB(const FUniqueBoolQuery& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; - Column.ColumnName = TEXT("s"); + FBlueprintBoolColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("b"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString|Columns", meta=(DisplayName="PkString Data")) - static FBlueprintInt32Column PkStringData(const FPkStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool Data")) + static FBlueprintInt32Column UniqueBoolData(const FUniqueBoolQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_string") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkString", meta=(DisplayName="PkString Where")) - static FPkStringQuery PkStringWhere(FPkStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="UniqueBool Where")) + static FUniqueBoolQuery UniqueBoolWhere(FUniqueBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21345,17 +26099,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="From PkU128")) - static FPkU128Query FromPkU128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="From UniqueConnectionId")) + static FUniqueConnectionIdQuery FromUniqueConnectionId() { - FPkU128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU128().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_128"); + FUniqueConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU128QueryToBlueprintQuery(const FPkU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueConnectionIdQueryToBlueprintQuery(const FUniqueConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21363,17 +26117,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128|Columns", meta=(DisplayName="PkU128 Data")) - static FBlueprintInt32Column PkU128Data(const FPkU128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId A")) + static FBlueprintConnectionIdColumn UniqueConnectionIdA(const FUniqueConnectionIdQuery& Query) + { + FBlueprintConnectionIdColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("a"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId Data")) + static FBlueprintInt32Column UniqueConnectionIdData(const FUniqueConnectionIdQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_128") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU128", meta=(DisplayName="PkU128 Where")) - static FPkU128Query PkU128Where(FPkU128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="UniqueConnectionId Where")) + static FUniqueConnectionIdQuery UniqueConnectionIdWhere(FUniqueConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21383,17 +26146,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="From PkU16")) - static FPkU16Query FromPkU16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="From UniqueI128")) + static FUniqueI128Query FromUniqueI128() { - FPkU16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU16().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_16"); + FUniqueI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU16QueryToBlueprintQuery(const FPkU16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI128QueryToBlueprintQuery(const FUniqueI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21401,17 +26164,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16|Columns", meta=(DisplayName="PkU16 Data")) - static FBlueprintInt32Column PkU16Data(const FPkU16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128|Columns", meta=(DisplayName="UniqueI128 Data")) + static FBlueprintInt32Column UniqueI128Data(const FUniqueI128Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_16") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_128") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU16", meta=(DisplayName="PkU16 Where")) - static FPkU16Query PkU16Where(FPkU16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="UniqueI128 Where")) + static FUniqueI128Query UniqueI128Where(FUniqueI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21421,17 +26184,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="From PkU256")) - static FPkU256Query FromPkU256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="From UniqueI16")) + static FUniqueI16Query FromUniqueI16() { - FPkU256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU256().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_256"); + FUniqueI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU256QueryToBlueprintQuery(const FPkU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI16QueryToBlueprintQuery(const FUniqueI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21439,17 +26202,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256|Columns", meta=(DisplayName="PkU256 Data")) - static FBlueprintInt32Column PkU256Data(const FPkU256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16|Columns", meta=(DisplayName="UniqueI16 Data")) + static FBlueprintInt32Column UniqueI16Data(const FUniqueI16Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_256") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_16") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU256", meta=(DisplayName="PkU256 Where")) - static FPkU256Query PkU256Where(FPkU256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="UniqueI16 Where")) + static FUniqueI16Query UniqueI16Where(FUniqueI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21459,17 +26222,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="From PkU32")) - static FPkU32Query FromPkU32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="From UniqueI256")) + static FUniqueI256Query FromUniqueI256() { - FPkU32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_32"); + FUniqueI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU32QueryToBlueprintQuery(const FPkU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI256QueryToBlueprintQuery(const FUniqueI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21477,17 +26240,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32|Columns", meta=(DisplayName="PkU32 Data")) - static FBlueprintInt32Column PkU32Data(const FPkU32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256|Columns", meta=(DisplayName="UniqueI256 Data")) + static FBlueprintInt32Column UniqueI256Data(const FUniqueI256Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_256") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32", meta=(DisplayName="PkU32 Where")) - static FPkU32Query PkU32Where(FPkU32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="UniqueI256 Where")) + static FUniqueI256Query UniqueI256Where(FUniqueI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21497,17 +26260,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="From PkU32Two")) - static FPkU32TwoQuery FromPkU32Two() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="From UniqueI32")) + static FUniqueI32Query FromUniqueI32() { - FPkU32TwoQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU32Two().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_32_two"); + FUniqueI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU32TwoQueryToBlueprintQuery(const FPkU32TwoQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI32QueryToBlueprintQuery(const FUniqueI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21515,17 +26278,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two|Columns", meta=(DisplayName="PkU32Two Data")) - static FBlueprintInt32Column PkU32TwoData(const FPkU32TwoQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 N")) + static FBlueprintInt32Column UniqueI32N(const FUniqueI32Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_32_two") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 Data")) + static FBlueprintInt32Column UniqueI32Data(const FUniqueI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU32Two", meta=(DisplayName="PkU32Two Where")) - static FPkU32TwoQuery PkU32TwoWhere(FPkU32TwoQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="UniqueI32 Where")) + static FUniqueI32Query UniqueI32Where(FUniqueI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21535,17 +26307,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="From PkU64")) - static FPkU64Query FromPkU64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="From UniqueI64")) + static FUniqueI64Query FromUniqueI64() { - FPkU64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU64().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_64"); + FUniqueI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU64QueryToBlueprintQuery(const FPkU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI64QueryToBlueprintQuery(const FUniqueI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21553,17 +26325,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64|Columns", meta=(DisplayName="PkU64 Data")) - static FBlueprintInt32Column PkU64Data(const FPkU64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 N")) + static FBlueprintInt64Column UniqueI64N(const FUniqueI64Query& Query) + { + FBlueprintInt64Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("n"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 Data")) + static FBlueprintInt32Column UniqueI64Data(const FUniqueI64Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_64") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU64", meta=(DisplayName="PkU64 Where")) - static FPkU64Query PkU64Where(FPkU64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="UniqueI64 Where")) + static FUniqueI64Query UniqueI64Where(FUniqueI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21573,17 +26354,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="From PkU8")) - static FPkU8Query FromPkU8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="From UniqueI8")) + static FUniqueI8Query FromUniqueI8() { - FPkU8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkU8().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_u_8"); + FUniqueI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkU8QueryToBlueprintQuery(const FPkU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueI8QueryToBlueprintQuery(const FUniqueI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21591,26 +26372,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 N")) - static FBlueprintUInt8Column PkU8N(const FPkU8Query& Query) - { - FBlueprintUInt8Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8|Columns", meta=(DisplayName="PkU8 Data")) - static FBlueprintInt32Column PkU8Data(const FPkU8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8|Columns", meta=(DisplayName="UniqueI8 Data")) + static FBlueprintInt32Column UniqueI8Data(const FUniqueI8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_u_8") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkU8", meta=(DisplayName="PkU8 Where")) - static FPkU8Query PkU8Where(FPkU8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="UniqueI8 Where")) + static FUniqueI8Query UniqueI8Where(FUniqueI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21620,17 +26392,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="From PkUuid")) - static FPkUuidQuery FromPkUuid() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="From UniqueIdentity")) + static FUniqueIdentityQuery FromUniqueIdentity() { - FPkUuidQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.PkUuid().into_sql().c_str())); - Query.ResultSourceName = TEXT("pk_uuid"); + FUniqueIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_PkUuidQueryToBlueprintQuery(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueIdentityQueryToBlueprintQuery(const FUniqueIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21638,26 +26410,26 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid U")) - static FBlueprintUuidColumn PkUuidU(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity I")) + static FBlueprintIdentityColumn UniqueIdentityI(const FUniqueIdentityQuery& Query) { - FBlueprintUuidColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; - Column.ColumnName = TEXT("u"); + FBlueprintIdentityColumn Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; + Column.ColumnName = TEXT("i"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid|Columns", meta=(DisplayName="PkUuid Data")) - static FBlueprintInt32Column PkUuidData(const FPkUuidQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity Data")) + static FBlueprintInt32Column UniqueIdentityData(const FUniqueIdentityQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("pk_uuid") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|PkUuid", meta=(DisplayName="PkUuid Where")) - static FPkUuidQuery PkUuidWhere(FPkUuidQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="UniqueIdentity Where")) + static FUniqueIdentityQuery UniqueIdentityWhere(FUniqueIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21667,17 +26439,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="From ResultEveryPrimitiveStructString")) - static FResultEveryPrimitiveStructStringQuery FromResultEveryPrimitiveStructString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="From UniqueOptionBool")) + static FUniqueOptionBoolQuery FromUniqueOptionBool() { - FResultEveryPrimitiveStructStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultEveryPrimitiveStructString().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_every_primitive_struct_string"); + FUniqueOptionBoolQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionBool().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_bool"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultEveryPrimitiveStructStringQueryToBlueprintQuery(const FResultEveryPrimitiveStructStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionBoolQueryToBlueprintQuery(const FUniqueOptionBoolQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21685,8 +26457,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultEveryPrimitiveStructString", meta=(DisplayName="ResultEveryPrimitiveStructString Where")) - static FResultEveryPrimitiveStructStringQuery ResultEveryPrimitiveStructStringWhere(FResultEveryPrimitiveStructStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool|Columns", meta=(DisplayName="UniqueOptionBool Data")) + static FBlueprintInt32Column UniqueOptionBoolData(const FUniqueOptionBoolQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_bool") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionBool", meta=(DisplayName="UniqueOptionBool Where")) + static FUniqueOptionBoolQuery UniqueOptionBoolWhere(FUniqueOptionBoolQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21696,17 +26477,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="From ResultI32String")) - static FResultI32StringQuery FromResultI32String() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="From UniqueOptionConnectionId")) + static FUniqueOptionConnectionIdQuery FromUniqueOptionConnectionId() { - FResultI32StringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultI32String().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_i_32_string"); + FUniqueOptionConnectionIdQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionConnectionId().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_connection_id"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultI32StringQueryToBlueprintQuery(const FResultI32StringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionConnectionIdQueryToBlueprintQuery(const FUniqueOptionConnectionIdQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21714,8 +26495,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultI32String", meta=(DisplayName="ResultI32String Where")) - static FResultI32StringQuery ResultI32StringWhere(FResultI32StringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId|Columns", meta=(DisplayName="UniqueOptionConnectionId Data")) + static FBlueprintInt32Column UniqueOptionConnectionIdData(const FUniqueOptionConnectionIdQuery& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_connection_id") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionConnectionId", meta=(DisplayName="UniqueOptionConnectionId Where")) + static FUniqueOptionConnectionIdQuery UniqueOptionConnectionIdWhere(FUniqueOptionConnectionIdQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21725,17 +26515,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="From ResultIdentityString")) - static FResultIdentityStringQuery FromResultIdentityString() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="From UniqueOptionI128")) + static FUniqueOptionI128Query FromUniqueOptionI128() { - FResultIdentityStringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultIdentityString().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_identity_string"); + FUniqueOptionI128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultIdentityStringQueryToBlueprintQuery(const FResultIdentityStringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI128QueryToBlueprintQuery(const FUniqueOptionI128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21743,8 +26533,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultIdentityString", meta=(DisplayName="ResultIdentityString Where")) - static FResultIdentityStringQuery ResultIdentityStringWhere(FResultIdentityStringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128|Columns", meta=(DisplayName="UniqueOptionI128 Data")) + static FBlueprintInt32Column UniqueOptionI128Data(const FUniqueOptionI128Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_128") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI128", meta=(DisplayName="UniqueOptionI128 Where")) + static FUniqueOptionI128Query UniqueOptionI128Where(FUniqueOptionI128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21754,17 +26553,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="From ResultSimpleEnumI32")) - static FResultSimpleEnumI32Query FromResultSimpleEnumI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="From UniqueOptionI16")) + static FUniqueOptionI16Query FromUniqueOptionI16() { - FResultSimpleEnumI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultSimpleEnumI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_simple_enum_i_32"); + FUniqueOptionI16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultSimpleEnumI32QueryToBlueprintQuery(const FResultSimpleEnumI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI16QueryToBlueprintQuery(const FUniqueOptionI16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21772,8 +26571,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultSimpleEnumI32", meta=(DisplayName="ResultSimpleEnumI32 Where")) - static FResultSimpleEnumI32Query ResultSimpleEnumI32Where(FResultSimpleEnumI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16|Columns", meta=(DisplayName="UniqueOptionI16 Data")) + static FBlueprintInt32Column UniqueOptionI16Data(const FUniqueOptionI16Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_16") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI16", meta=(DisplayName="UniqueOptionI16 Where")) + static FUniqueOptionI16Query UniqueOptionI16Where(FUniqueOptionI16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21783,17 +26591,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="From ResultStringI32")) - static FResultStringI32Query FromResultStringI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="From UniqueOptionI256")) + static FUniqueOptionI256Query FromUniqueOptionI256() { - FResultStringI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultStringI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_string_i_32"); + FUniqueOptionI256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultStringI32QueryToBlueprintQuery(const FResultStringI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI256QueryToBlueprintQuery(const FUniqueOptionI256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21801,8 +26609,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultStringI32", meta=(DisplayName="ResultStringI32 Where")) - static FResultStringI32Query ResultStringI32Where(FResultStringI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256|Columns", meta=(DisplayName="UniqueOptionI256 Data")) + static FBlueprintInt32Column UniqueOptionI256Data(const FUniqueOptionI256Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_256") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI256", meta=(DisplayName="UniqueOptionI256 Where")) + static FUniqueOptionI256Query UniqueOptionI256Where(FUniqueOptionI256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21812,17 +26629,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="From ResultVecI32String")) - static FResultVecI32StringQuery FromResultVecI32String() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="From UniqueOptionI32")) + static FUniqueOptionI32Query FromUniqueOptionI32() { - FResultVecI32StringQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ResultVecI32String().into_sql().c_str())); - Query.ResultSourceName = TEXT("result_vec_i_32_string"); + FUniqueOptionI32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ResultVecI32StringQueryToBlueprintQuery(const FResultVecI32StringQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI32QueryToBlueprintQuery(const FUniqueOptionI32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21830,8 +26647,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ResultVecI32String", meta=(DisplayName="ResultVecI32String Where")) - static FResultVecI32StringQuery ResultVecI32StringWhere(FResultVecI32StringQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32|Columns", meta=(DisplayName="UniqueOptionI32 Data")) + static FBlueprintInt32Column UniqueOptionI32Data(const FUniqueOptionI32Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_32") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI32", meta=(DisplayName="UniqueOptionI32 Where")) + static FUniqueOptionI32Query UniqueOptionI32Where(FUniqueOptionI32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21841,17 +26667,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="From ScheduledTable")) - static FScheduledTableQuery FromScheduledTable() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="From UniqueOptionI64")) + static FUniqueOptionI64Query FromUniqueOptionI64() { - FScheduledTableQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.ScheduledTable().into_sql().c_str())); - Query.ResultSourceName = TEXT("scheduled_table"); + FUniqueOptionI64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_ScheduledTableQueryToBlueprintQuery(const FScheduledTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI64QueryToBlueprintQuery(const FUniqueOptionI64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21859,17 +26685,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable|Columns", meta=(DisplayName="ScheduledTable Text")) - static FBlueprintStringColumn ScheduledTableText(const FScheduledTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64|Columns", meta=(DisplayName="UniqueOptionI64 Data")) + static FBlueprintInt32Column UniqueOptionI64Data(const FUniqueOptionI64Query& Query) { - FBlueprintStringColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("scheduled_table") : Query.ResultSourceName; - Column.ColumnName = TEXT("text"); + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_64") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|ScheduledTable", meta=(DisplayName="ScheduledTable Where")) - static FScheduledTableQuery ScheduledTableWhere(FScheduledTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI64", meta=(DisplayName="UniqueOptionI64 Where")) + static FUniqueOptionI64Query UniqueOptionI64Where(FUniqueOptionI64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21879,17 +26705,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="From TableHoldsTable")) - static FTableHoldsTableQuery FromTableHoldsTable() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="From UniqueOptionI8")) + static FUniqueOptionI8Query FromUniqueOptionI8() { - FTableHoldsTableQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.TableHoldsTable().into_sql().c_str())); - Query.ResultSourceName = TEXT("table_holds_table"); + FUniqueOptionI8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionI8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_i_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_TableHoldsTableQueryToBlueprintQuery(const FTableHoldsTableQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionI8QueryToBlueprintQuery(const FUniqueOptionI8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21897,8 +26723,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|TableHoldsTable", meta=(DisplayName="TableHoldsTable Where")) - static FTableHoldsTableQuery TableHoldsTableWhere(FTableHoldsTableQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8|Columns", meta=(DisplayName="UniqueOptionI8 Data")) + static FBlueprintInt32Column UniqueOptionI8Data(const FUniqueOptionI8Query& Query) + { + FBlueprintInt32Column Column; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_i_8") : Query.ResultSourceName; + Column.ColumnName = TEXT("data"); + return Column; + } + + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionI8", meta=(DisplayName="UniqueOptionI8 Where")) + static FUniqueOptionI8Query UniqueOptionI8Where(FUniqueOptionI8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21908,17 +26743,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="From UniqueBool")) - static FUniqueBoolQuery FromUniqueBool() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="From UniqueOptionIdentity")) + static FUniqueOptionIdentityQuery FromUniqueOptionIdentity() { - FUniqueBoolQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueBool().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_bool"); + FUniqueOptionIdentityQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionIdentity().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_identity"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueBoolQueryToBlueprintQuery(const FUniqueBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionIdentityQueryToBlueprintQuery(const FUniqueOptionIdentityQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21926,26 +26761,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool B")) - static FBlueprintBoolColumn UniqueBoolB(const FUniqueBoolQuery& Query) - { - FBlueprintBoolColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; - Column.ColumnName = TEXT("b"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool|Columns", meta=(DisplayName="UniqueBool Data")) - static FBlueprintInt32Column UniqueBoolData(const FUniqueBoolQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity|Columns", meta=(DisplayName="UniqueOptionIdentity Data")) + static FBlueprintInt32Column UniqueOptionIdentityData(const FUniqueOptionIdentityQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_bool") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_identity") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueBool", meta=(DisplayName="UniqueBool Where")) - static FUniqueBoolQuery UniqueBoolWhere(FUniqueBoolQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionIdentity", meta=(DisplayName="UniqueOptionIdentity Where")) + static FUniqueOptionIdentityQuery UniqueOptionIdentityWhere(FUniqueOptionIdentityQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -21955,17 +26781,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="From UniqueConnectionId")) - static FUniqueConnectionIdQuery FromUniqueConnectionId() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="From UniqueOptionString")) + static FUniqueOptionStringQuery FromUniqueOptionString() { - FUniqueConnectionIdQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueConnectionId().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_connection_id"); + FUniqueOptionStringQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionString().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_string"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueConnectionIdQueryToBlueprintQuery(const FUniqueConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionStringQueryToBlueprintQuery(const FUniqueOptionStringQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -21973,26 +26799,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId A")) - static FBlueprintConnectionIdColumn UniqueConnectionIdA(const FUniqueConnectionIdQuery& Query) - { - FBlueprintConnectionIdColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; - Column.ColumnName = TEXT("a"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId|Columns", meta=(DisplayName="UniqueConnectionId Data")) - static FBlueprintInt32Column UniqueConnectionIdData(const FUniqueConnectionIdQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString|Columns", meta=(DisplayName="UniqueOptionString Data")) + static FBlueprintInt32Column UniqueOptionStringData(const FUniqueOptionStringQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_connection_id") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_string") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueConnectionId", meta=(DisplayName="UniqueConnectionId Where")) - static FUniqueConnectionIdQuery UniqueConnectionIdWhere(FUniqueConnectionIdQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionString", meta=(DisplayName="UniqueOptionString Where")) + static FUniqueOptionStringQuery UniqueOptionStringWhere(FUniqueOptionStringQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22002,17 +26819,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="From UniqueI128")) - static FUniqueI128Query FromUniqueI128() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="From UniqueOptionU128")) + static FUniqueOptionU128Query FromUniqueOptionU128() { - FUniqueI128Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI128().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_128"); + FUniqueOptionU128Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU128().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_128"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI128QueryToBlueprintQuery(const FUniqueI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU128QueryToBlueprintQuery(const FUniqueOptionU128Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22020,17 +26837,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128|Columns", meta=(DisplayName="UniqueI128 Data")) - static FBlueprintInt32Column UniqueI128Data(const FUniqueI128Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128|Columns", meta=(DisplayName="UniqueOptionU128 Data")) + static FBlueprintInt32Column UniqueOptionU128Data(const FUniqueOptionU128Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_128") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_128") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI128", meta=(DisplayName="UniqueI128 Where")) - static FUniqueI128Query UniqueI128Where(FUniqueI128Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU128", meta=(DisplayName="UniqueOptionU128 Where")) + static FUniqueOptionU128Query UniqueOptionU128Where(FUniqueOptionU128Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22040,17 +26857,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="From UniqueI16")) - static FUniqueI16Query FromUniqueI16() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="From UniqueOptionU16")) + static FUniqueOptionU16Query FromUniqueOptionU16() { - FUniqueI16Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI16().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_16"); + FUniqueOptionU16Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU16().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_16"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI16QueryToBlueprintQuery(const FUniqueI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU16QueryToBlueprintQuery(const FUniqueOptionU16Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22058,17 +26875,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16|Columns", meta=(DisplayName="UniqueI16 Data")) - static FBlueprintInt32Column UniqueI16Data(const FUniqueI16Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16|Columns", meta=(DisplayName="UniqueOptionU16 Data")) + static FBlueprintInt32Column UniqueOptionU16Data(const FUniqueOptionU16Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_16") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_16") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI16", meta=(DisplayName="UniqueI16 Where")) - static FUniqueI16Query UniqueI16Where(FUniqueI16Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU16", meta=(DisplayName="UniqueOptionU16 Where")) + static FUniqueOptionU16Query UniqueOptionU16Where(FUniqueOptionU16Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22078,17 +26895,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="From UniqueI256")) - static FUniqueI256Query FromUniqueI256() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="From UniqueOptionU256")) + static FUniqueOptionU256Query FromUniqueOptionU256() { - FUniqueI256Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI256().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_256"); + FUniqueOptionU256Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU256().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_256"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI256QueryToBlueprintQuery(const FUniqueI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU256QueryToBlueprintQuery(const FUniqueOptionU256Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22096,17 +26913,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256|Columns", meta=(DisplayName="UniqueI256 Data")) - static FBlueprintInt32Column UniqueI256Data(const FUniqueI256Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256|Columns", meta=(DisplayName="UniqueOptionU256 Data")) + static FBlueprintInt32Column UniqueOptionU256Data(const FUniqueOptionU256Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_256") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_256") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI256", meta=(DisplayName="UniqueI256 Where")) - static FUniqueI256Query UniqueI256Where(FUniqueI256Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU256", meta=(DisplayName="UniqueOptionU256 Where")) + static FUniqueOptionU256Query UniqueOptionU256Where(FUniqueOptionU256Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22116,17 +26933,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="From UniqueI32")) - static FUniqueI32Query FromUniqueI32() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="From UniqueOptionU32")) + static FUniqueOptionU32Query FromUniqueOptionU32() { - FUniqueI32Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI32().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_32"); + FUniqueOptionU32Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU32().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_32"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI32QueryToBlueprintQuery(const FUniqueI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU32QueryToBlueprintQuery(const FUniqueOptionU32Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22134,26 +26951,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 N")) - static FBlueprintInt32Column UniqueI32N(const FUniqueI32Query& Query) - { - FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32|Columns", meta=(DisplayName="UniqueI32 Data")) - static FBlueprintInt32Column UniqueI32Data(const FUniqueI32Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32|Columns", meta=(DisplayName="UniqueOptionU32 Data")) + static FBlueprintInt32Column UniqueOptionU32Data(const FUniqueOptionU32Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_32") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_32") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI32", meta=(DisplayName="UniqueI32 Where")) - static FUniqueI32Query UniqueI32Where(FUniqueI32Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU32", meta=(DisplayName="UniqueOptionU32 Where")) + static FUniqueOptionU32Query UniqueOptionU32Where(FUniqueOptionU32Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22163,17 +26971,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="From UniqueI64")) - static FUniqueI64Query FromUniqueI64() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="From UniqueOptionU64")) + static FUniqueOptionU64Query FromUniqueOptionU64() { - FUniqueI64Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI64().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_64"); + FUniqueOptionU64Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU64().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_64"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI64QueryToBlueprintQuery(const FUniqueI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU64QueryToBlueprintQuery(const FUniqueOptionU64Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22181,26 +26989,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 N")) - static FBlueprintInt64Column UniqueI64N(const FUniqueI64Query& Query) - { - FBlueprintInt64Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; - Column.ColumnName = TEXT("n"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64|Columns", meta=(DisplayName="UniqueI64 Data")) - static FBlueprintInt32Column UniqueI64Data(const FUniqueI64Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64|Columns", meta=(DisplayName="UniqueOptionU64 Data")) + static FBlueprintInt32Column UniqueOptionU64Data(const FUniqueOptionU64Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_64") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_64") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI64", meta=(DisplayName="UniqueI64 Where")) - static FUniqueI64Query UniqueI64Where(FUniqueI64Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU64", meta=(DisplayName="UniqueOptionU64 Where")) + static FUniqueOptionU64Query UniqueOptionU64Where(FUniqueOptionU64Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22210,17 +27009,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="From UniqueI8")) - static FUniqueI8Query FromUniqueI8() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="From UniqueOptionU8")) + static FUniqueOptionU8Query FromUniqueOptionU8() { - FUniqueI8Query Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueI8().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_i_8"); + FUniqueOptionU8Query Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionU8().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_u_8"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueI8QueryToBlueprintQuery(const FUniqueI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionU8QueryToBlueprintQuery(const FUniqueOptionU8Query& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22228,17 +27027,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8|Columns", meta=(DisplayName="UniqueI8 Data")) - static FBlueprintInt32Column UniqueI8Data(const FUniqueI8Query& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8|Columns", meta=(DisplayName="UniqueOptionU8 Data")) + static FBlueprintInt32Column UniqueOptionU8Data(const FUniqueOptionU8Query& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_i_8") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_u_8") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueI8", meta=(DisplayName="UniqueI8 Where")) - static FUniqueI8Query UniqueI8Where(FUniqueI8Query Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionU8", meta=(DisplayName="UniqueOptionU8 Where")) + static FUniqueOptionU8Query UniqueOptionU8Where(FUniqueOptionU8Query Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -22248,17 +27047,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="From UniqueIdentity")) - static FUniqueIdentityQuery FromUniqueIdentity() + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="From UniqueOptionUuid")) + static FUniqueOptionUuidQuery FromUniqueOptionUuid() { - FUniqueIdentityQuery Query; - Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueIdentity().into_sql().c_str())); - Query.ResultSourceName = TEXT("unique_identity"); + FUniqueOptionUuidQuery Query; + Query.Sql = FString(UTF8_TO_TCHAR(FQueryBuilder().From.UniqueOptionUuid().into_sql().c_str())); + Query.ResultSourceName = TEXT("unique_option_uuid"); return Query; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="To Query", BlueprintAutocast)) - static FBlueprintQuery Conv_UniqueIdentityQueryToBlueprintQuery(const FUniqueIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="To Query", BlueprintAutocast)) + static FBlueprintQuery Conv_UniqueOptionUuidQueryToBlueprintQuery(const FUniqueOptionUuidQuery& Query) { FBlueprintQuery GenericQuery; GenericQuery.Sql = Query.Sql; @@ -22266,26 +27065,17 @@ class TESTCLIENT_API UQueryBuilderBlueprintLibrary : public UBlueprintFunctionLi return GenericQuery; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity I")) - static FBlueprintIdentityColumn UniqueIdentityI(const FUniqueIdentityQuery& Query) - { - FBlueprintIdentityColumn Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; - Column.ColumnName = TEXT("i"); - return Column; - } - - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity|Columns", meta=(DisplayName="UniqueIdentity Data")) - static FBlueprintInt32Column UniqueIdentityData(const FUniqueIdentityQuery& Query) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid|Columns", meta=(DisplayName="UniqueOptionUuid Data")) + static FBlueprintInt32Column UniqueOptionUuidData(const FUniqueOptionUuidQuery& Query) { FBlueprintInt32Column Column; - Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_identity") : Query.ResultSourceName; + Column.ResultSourceName = Query.ResultSourceName.IsEmpty() ? TEXT("unique_option_uuid") : Query.ResultSourceName; Column.ColumnName = TEXT("data"); return Column; } - UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueIdentity", meta=(DisplayName="UniqueIdentity Where")) - static FUniqueIdentityQuery UniqueIdentityWhere(FUniqueIdentityQuery Query, const FBlueprintPredicate& Predicate) + UFUNCTION(BlueprintPure, Category="SpacetimeDB|Queries|UniqueOptionUuid", meta=(DisplayName="UniqueOptionUuid Where")) + static FUniqueOptionUuidQuery UniqueOptionUuidWhere(FUniqueOptionUuidQuery Query, const FBlueprintPredicate& Predicate) { if (Query.ResultSourceName != Predicate.ResultSourceName || Predicate.Sql.IsEmpty()) { @@ -23957,6 +28747,40 @@ class TESTCLIENT_API USubscriptionBuilder : public USubscriptionBuilderBase USubscriptionBuilder* AddUniqueIdentityQuery(const FUniqueIdentityQuery& Query); + USubscriptionBuilder* AddUniqueOptionBoolQuery(const FUniqueOptionBoolQuery& Query); + + USubscriptionBuilder* AddUniqueOptionConnectionIdQuery(const FUniqueOptionConnectionIdQuery& Query); + + USubscriptionBuilder* AddUniqueOptionI128Query(const FUniqueOptionI128Query& Query); + + USubscriptionBuilder* AddUniqueOptionI16Query(const FUniqueOptionI16Query& Query); + + USubscriptionBuilder* AddUniqueOptionI256Query(const FUniqueOptionI256Query& Query); + + USubscriptionBuilder* AddUniqueOptionI32Query(const FUniqueOptionI32Query& Query); + + USubscriptionBuilder* AddUniqueOptionI64Query(const FUniqueOptionI64Query& Query); + + USubscriptionBuilder* AddUniqueOptionI8Query(const FUniqueOptionI8Query& Query); + + USubscriptionBuilder* AddUniqueOptionIdentityQuery(const FUniqueOptionIdentityQuery& Query); + + USubscriptionBuilder* AddUniqueOptionStringQuery(const FUniqueOptionStringQuery& Query); + + USubscriptionBuilder* AddUniqueOptionU128Query(const FUniqueOptionU128Query& Query); + + USubscriptionBuilder* AddUniqueOptionU16Query(const FUniqueOptionU16Query& Query); + + USubscriptionBuilder* AddUniqueOptionU256Query(const FUniqueOptionU256Query& Query); + + USubscriptionBuilder* AddUniqueOptionU32Query(const FUniqueOptionU32Query& Query); + + USubscriptionBuilder* AddUniqueOptionU64Query(const FUniqueOptionU64Query& Query); + + USubscriptionBuilder* AddUniqueOptionU8Query(const FUniqueOptionU8Query& Query); + + USubscriptionBuilder* AddUniqueOptionUuidQuery(const FUniqueOptionUuidQuery& Query); + USubscriptionBuilder* AddUniqueStringQuery(const FUniqueStringQuery& Query); USubscriptionBuilder* AddUniqueU128Query(const FUniqueU128Query& Query); diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h new file mode 100644 index 00000000000..a380b8df12d --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionBoolTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionBoolType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionBoolTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionBoolBUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> BIndexHelper; + +public: + UUniqueOptionBoolBUniqueIndex() + // Initialize the helper with the specific unique index name + : BIndexHelper("b") { + } + + /** + * Finds a UniqueOptionBool by their unique b. + * @param Key The b to search for. + * @return The found FUniqueOptionBoolType, or a default-constructed FUniqueOptionBoolType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionBoolIndex") + FUniqueOptionBoolType Find(FTestClientOptionalBool Key) + { + // Simply delegate the call to the internal helper + return BIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionBoolCache) + { + BIndexHelper.Cache = InUniqueOptionBoolCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionBoolTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionBoolBUniqueIndex* B; + + void PostInitialize(); + + /** Update function for unique_option_bool table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionBoolInsert, + const FEventContext&, Context, + const FUniqueOptionBoolType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionBoolUpdate, + const FEventContext&, Context, + const FUniqueOptionBoolType&, OldRow, + const FUniqueOptionBoolType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionBoolDelete, + const FEventContext&, Context, + const FUniqueOptionBoolType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionBoolDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_bool"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h new file mode 100644 index 00000000000..0815312c56b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionConnectionIdType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionConnectionIdTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionConnectionIdAUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> AIndexHelper; + +public: + UUniqueOptionConnectionIdAUniqueIndex() + // Initialize the helper with the specific unique index name + : AIndexHelper("a") { + } + + /** + * Finds a UniqueOptionConnectionId by their unique a. + * @param Key The a to search for. + * @return The found FUniqueOptionConnectionIdType, or a default-constructed FUniqueOptionConnectionIdType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionConnectionIdIndex") + FUniqueOptionConnectionIdType Find(FTestClientOptionalConnectionId Key) + { + // Simply delegate the call to the internal helper + return AIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionConnectionIdCache) + { + AIndexHelper.Cache = InUniqueOptionConnectionIdCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionConnectionIdTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionConnectionIdAUniqueIndex* A; + + void PostInitialize(); + + /** Update function for unique_option_connection_id table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionConnectionIdInsert, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionConnectionIdUpdate, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, OldRow, + const FUniqueOptionConnectionIdType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionConnectionIdDelete, + const FEventContext&, Context, + const FUniqueOptionConnectionIdType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionConnectionIdDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_connection_id"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h new file mode 100644 index 00000000000..f0610ad66f5 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI128Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI128Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI128Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI128NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI128NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI128 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI128Type, or a default-constructed FUniqueOptionI128Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI128Index") + FUniqueOptionI128Type Find(FTestClientOptionalInt128 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI128Cache) + { + NIndexHelper.Cache = InUniqueOptionI128Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI128Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI128NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_128 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI128Insert, + const FEventContext&, Context, + const FUniqueOptionI128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI128Update, + const FEventContext&, Context, + const FUniqueOptionI128Type&, OldRow, + const FUniqueOptionI128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI128Delete, + const FEventContext&, Context, + const FUniqueOptionI128Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI128Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_128"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h new file mode 100644 index 00000000000..dafef01fb9c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI16Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI16Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI16Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI16NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI16NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI16 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI16Type, or a default-constructed FUniqueOptionI16Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt16 types are not Blueprint-compatible + FUniqueOptionI16Type Find(FTestClientOptionalInt16 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI16Cache) + { + NIndexHelper.Cache = InUniqueOptionI16Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI16Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI16NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_16 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI16Insert, + const FEventContext&, Context, + const FUniqueOptionI16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI16Update, + const FEventContext&, Context, + const FUniqueOptionI16Type&, OldRow, + const FUniqueOptionI16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI16Delete, + const FEventContext&, Context, + const FUniqueOptionI16Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI16Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_16"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h new file mode 100644 index 00000000000..90978f35ba3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI256Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI256Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI256Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI256NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI256NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI256 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI256Type, or a default-constructed FUniqueOptionI256Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI256Index") + FUniqueOptionI256Type Find(FTestClientOptionalInt256 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI256Cache) + { + NIndexHelper.Cache = InUniqueOptionI256Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI256Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI256NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_256 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI256Insert, + const FEventContext&, Context, + const FUniqueOptionI256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI256Update, + const FEventContext&, Context, + const FUniqueOptionI256Type&, OldRow, + const FUniqueOptionI256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI256Delete, + const FEventContext&, Context, + const FUniqueOptionI256Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI256Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_256"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h new file mode 100644 index 00000000000..aae5e1112e1 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI32Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI32Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI32Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI32NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI32NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI32 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI32Type, or a default-constructed FUniqueOptionI32Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI32Index") + FUniqueOptionI32Type Find(FTestClientOptionalInt32 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI32Cache) + { + NIndexHelper.Cache = InUniqueOptionI32Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI32Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI32NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_32 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI32Insert, + const FEventContext&, Context, + const FUniqueOptionI32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI32Update, + const FEventContext&, Context, + const FUniqueOptionI32Type&, OldRow, + const FUniqueOptionI32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI32Delete, + const FEventContext&, Context, + const FUniqueOptionI32Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI32Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_32"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h new file mode 100644 index 00000000000..e82a235e134 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI64Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI64Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI64Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI64NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI64NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI64 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI64Type, or a default-constructed FUniqueOptionI64Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionI64Index") + FUniqueOptionI64Type Find(FTestClientOptionalInt64 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI64Cache) + { + NIndexHelper.Cache = InUniqueOptionI64Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI64Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI64NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_64 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI64Insert, + const FEventContext&, Context, + const FUniqueOptionI64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI64Update, + const FEventContext&, Context, + const FUniqueOptionI64Type&, OldRow, + const FUniqueOptionI64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI64Delete, + const FEventContext&, Context, + const FUniqueOptionI64Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI64Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_64"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h new file mode 100644 index 00000000000..894d5079c93 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionI8Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionI8Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionI8Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionI8NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionI8NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionI8 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionI8Type, or a default-constructed FUniqueOptionI8Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalInt8 types are not Blueprint-compatible + FUniqueOptionI8Type Find(FTestClientOptionalInt8 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionI8Cache) + { + NIndexHelper.Cache = InUniqueOptionI8Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionI8Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionI8NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_i_8 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI8Insert, + const FEventContext&, Context, + const FUniqueOptionI8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionI8Update, + const FEventContext&, Context, + const FUniqueOptionI8Type&, OldRow, + const FUniqueOptionI8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionI8Delete, + const FEventContext&, Context, + const FUniqueOptionI8Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionI8Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_i_8"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h new file mode 100644 index 00000000000..ec2f4860a51 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionIdentityTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionIdentityType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionIdentityTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionIdentityIUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> IIndexHelper; + +public: + UUniqueOptionIdentityIUniqueIndex() + // Initialize the helper with the specific unique index name + : IIndexHelper("i") { + } + + /** + * Finds a UniqueOptionIdentity by their unique i. + * @param Key The i to search for. + * @return The found FUniqueOptionIdentityType, or a default-constructed FUniqueOptionIdentityType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionIdentityIndex") + FUniqueOptionIdentityType Find(FTestClientOptionalIdentity Key) + { + // Simply delegate the call to the internal helper + return IIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionIdentityCache) + { + IIndexHelper.Cache = InUniqueOptionIdentityCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionIdentityTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionIdentityIUniqueIndex* I; + + void PostInitialize(); + + /** Update function for unique_option_identity table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionIdentityInsert, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionIdentityUpdate, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, OldRow, + const FUniqueOptionIdentityType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionIdentityDelete, + const FEventContext&, Context, + const FUniqueOptionIdentityType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionIdentityDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_identity"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h new file mode 100644 index 00000000000..3c9e9d02081 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionStringTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionStringType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionStringTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionStringSUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> SIndexHelper; + +public: + UUniqueOptionStringSUniqueIndex() + // Initialize the helper with the specific unique index name + : SIndexHelper("s") { + } + + /** + * Finds a UniqueOptionString by their unique s. + * @param Key The s to search for. + * @return The found FUniqueOptionStringType, or a default-constructed FUniqueOptionStringType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionStringIndex") + FUniqueOptionStringType Find(FTestClientOptionalString Key) + { + // Simply delegate the call to the internal helper + return SIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionStringCache) + { + SIndexHelper.Cache = InUniqueOptionStringCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionStringTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionStringSUniqueIndex* S; + + void PostInitialize(); + + /** Update function for unique_option_string table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionStringInsert, + const FEventContext&, Context, + const FUniqueOptionStringType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionStringUpdate, + const FEventContext&, Context, + const FUniqueOptionStringType&, OldRow, + const FUniqueOptionStringType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionStringDelete, + const FEventContext&, Context, + const FUniqueOptionStringType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionStringDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_string"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h new file mode 100644 index 00000000000..0e0d9144cc0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU128Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU128Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU128Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU128NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU128NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU128 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU128Type, or a default-constructed FUniqueOptionU128Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU128Index") + FUniqueOptionU128Type Find(FTestClientOptionalUInt128 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU128Cache) + { + NIndexHelper.Cache = InUniqueOptionU128Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU128Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU128NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_128 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU128Insert, + const FEventContext&, Context, + const FUniqueOptionU128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU128Update, + const FEventContext&, Context, + const FUniqueOptionU128Type&, OldRow, + const FUniqueOptionU128Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU128Delete, + const FEventContext&, Context, + const FUniqueOptionU128Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU128Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_128"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h new file mode 100644 index 00000000000..66b6bb96722 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU16Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU16Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU16Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU16NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU16NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU16 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU16Type, or a default-constructed FUniqueOptionU16Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt16 types are not Blueprint-compatible + FUniqueOptionU16Type Find(FTestClientOptionalUInt16 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU16Cache) + { + NIndexHelper.Cache = InUniqueOptionU16Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU16Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU16NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_16 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU16Insert, + const FEventContext&, Context, + const FUniqueOptionU16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU16Update, + const FEventContext&, Context, + const FUniqueOptionU16Type&, OldRow, + const FUniqueOptionU16Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU16Delete, + const FEventContext&, Context, + const FUniqueOptionU16Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU16Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_16"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h new file mode 100644 index 00000000000..f7e79d68064 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU256Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU256Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU256Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU256NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU256NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU256 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU256Type, or a default-constructed FUniqueOptionU256Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU256Index") + FUniqueOptionU256Type Find(FTestClientOptionalUInt256 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU256Cache) + { + NIndexHelper.Cache = InUniqueOptionU256Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU256Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU256NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_256 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU256Insert, + const FEventContext&, Context, + const FUniqueOptionU256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU256Update, + const FEventContext&, Context, + const FUniqueOptionU256Type&, OldRow, + const FUniqueOptionU256Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU256Delete, + const FEventContext&, Context, + const FUniqueOptionU256Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU256Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_256"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h new file mode 100644 index 00000000000..b96a68b4ddf --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU32Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU32Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU32Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU32NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU32NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU32 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU32Type, or a default-constructed FUniqueOptionU32Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt32 types are not Blueprint-compatible + FUniqueOptionU32Type Find(FTestClientOptionalUInt32 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU32Cache) + { + NIndexHelper.Cache = InUniqueOptionU32Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU32Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU32NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_32 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU32Insert, + const FEventContext&, Context, + const FUniqueOptionU32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU32Update, + const FEventContext&, Context, + const FUniqueOptionU32Type&, OldRow, + const FUniqueOptionU32Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU32Delete, + const FEventContext&, Context, + const FUniqueOptionU32Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU32Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_32"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h new file mode 100644 index 00000000000..2411c430785 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU64Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU64Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU64Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU64NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU64NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU64 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU64Type, or a default-constructed FUniqueOptionU64Type if not found. + */ + // NOTE: Not exposed to Blueprint because FTestClientOptionalUInt64 types are not Blueprint-compatible + FUniqueOptionU64Type Find(FTestClientOptionalUInt64 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU64Cache) + { + NIndexHelper.Cache = InUniqueOptionU64Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU64Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU64NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_64 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU64Insert, + const FEventContext&, Context, + const FUniqueOptionU64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU64Update, + const FEventContext&, Context, + const FUniqueOptionU64Type&, OldRow, + const FUniqueOptionU64Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU64Delete, + const FEventContext&, Context, + const FUniqueOptionU64Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU64Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_64"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h new file mode 100644 index 00000000000..e2764539b3c --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionU8Table.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionU8Type.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionU8Table.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionU8NUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> NIndexHelper; + +public: + UUniqueOptionU8NUniqueIndex() + // Initialize the helper with the specific unique index name + : NIndexHelper("n") { + } + + /** + * Finds a UniqueOptionU8 by their unique n. + * @param Key The n to search for. + * @return The found FUniqueOptionU8Type, or a default-constructed FUniqueOptionU8Type if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionU8Index") + FUniqueOptionU8Type Find(FTestClientOptionalUInt8 Key) + { + // Simply delegate the call to the internal helper + return NIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionU8Cache) + { + NIndexHelper.Cache = InUniqueOptionU8Cache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionU8Table : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionU8NUniqueIndex* N; + + void PostInitialize(); + + /** Update function for unique_option_u_8 table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU8Insert, + const FEventContext&, Context, + const FUniqueOptionU8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionU8Update, + const FEventContext&, Context, + const FUniqueOptionU8Type&, OldRow, + const FUniqueOptionU8Type&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionU8Delete, + const FEventContext&, Context, + const FUniqueOptionU8Type&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Insert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Update OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionU8Delete OnDelete; + +private: + const FString TableName = TEXT("unique_option_u_8"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h new file mode 100644 index 00000000000..2d91366e0bf --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/UniqueOptionUuidTable.g.h @@ -0,0 +1,104 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "Types/Builtins.h" +#include "ModuleBindings/Types/UniqueOptionUuidType.g.h" +#include "Tables/RemoteTable.h" +#include "DBCache/WithBsatn.h" +#include "DBCache/TableHandle.h" +#include "DBCache/TableCache.h" +#include "UniqueOptionUuidTable.g.generated.h" + +UCLASS(Blueprintable) +class TESTCLIENT_API UUniqueOptionUuidUUniqueIndex : public UObject +{ + GENERATED_BODY() + +private: + // Declare an instance of your templated helper. + // It's private because the UObject wrapper will expose its functionality. + FUniqueIndexHelper> UIndexHelper; + +public: + UUniqueOptionUuidUUniqueIndex() + // Initialize the helper with the specific unique index name + : UIndexHelper("u") { + } + + /** + * Finds a UniqueOptionUuid by their unique u. + * @param Key The u to search for. + * @return The found FUniqueOptionUuidType, or a default-constructed FUniqueOptionUuidType if not found. + */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB|UniqueOptionUuidIndex") + FUniqueOptionUuidType Find(FTestClientOptionalUuid Key) + { + // Simply delegate the call to the internal helper + return UIndexHelper.FindUniqueIndex(Key); + } + + // A public setter to provide the cache to the helper after construction + // This is a common pattern when the cache might be created or provided by another system. + void SetCache(TSharedPtr> InUniqueOptionUuidCache) + { + UIndexHelper.Cache = InUniqueOptionUuidCache; + } +}; +/***/ + +UCLASS(BlueprintType) +class TESTCLIENT_API UUniqueOptionUuidTable : public URemoteTable +{ + GENERATED_BODY() + +public: + UPROPERTY(BlueprintReadOnly) + UUniqueOptionUuidUUniqueIndex* U; + + void PostInitialize(); + + /** Update function for unique_option_uuid table*/ + FTableAppliedDiff Update(TArray> InsertsRef, TArray> DeletesRef); + + /** Number of subscribed rows currently in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + int32 Count() const; + + /** Return all subscribed rows in the cache */ + UFUNCTION(BlueprintCallable, Category = "SpacetimeDB") + TArray Iter() const; + + // Table Events + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionUuidInsert, + const FEventContext&, Context, + const FUniqueOptionUuidType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( + FOnUniqueOptionUuidUpdate, + const FEventContext&, Context, + const FUniqueOptionUuidType&, OldRow, + const FUniqueOptionUuidType&, NewRow); + + DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( + FOnUniqueOptionUuidDelete, + const FEventContext&, Context, + const FUniqueOptionUuidType&, DeletedRow); + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidInsert OnInsert; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidUpdate OnUpdate; + + UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events") + FOnUniqueOptionUuidDelete OnDelete; + +private: + const FString TableName = TEXT("unique_option_uuid"); + + TSharedPtr> Data; +}; diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h index fa9b863fd39..9d4c678a794 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h @@ -4,9 +4,9 @@ #pragma once #include "CoreMinimal.h" #include "BSATN/UESpacetimeDB.h" -#include "Kismet/BlueprintFunctionLibrary.h" -#include "Types/Builtins.h" #include "ModuleBindings/Types/SimpleEnumType.g.h" +#include "Types/Builtins.h" +#include "Kismet/BlueprintFunctionLibrary.h" #include "EnumWithPayloadType.g.generated.h" UENUM(BlueprintType) @@ -46,7 +46,7 @@ struct TESTCLIENT_API FEnumWithPayloadType public: FEnumWithPayloadType() = default; - TVariant, FSpacetimeDBInt128, FSpacetimeDBConnectionId, uint8, TArray, FSpacetimeDBInt256, TArray, TArray, FSpacetimeDBUuid, int8, FSpacetimeDBUInt256, float, int64, uint32, int16, int32, FSpacetimeDBUInt128> MessageData; + TVariant, FSpacetimeDBUInt128, FSpacetimeDBTimestamp, FSpacetimeDBConnectionId, uint16, int64, TArray, FSpacetimeDBUInt256, int32, FSpacetimeDBInt256, int16, bool, FString, uint8, uint64, FSpacetimeDBInt128, float, TArray, TArray, int8, double, FSpacetimeDBUuid> MessageData; UPROPERTY(BlueprintReadOnly) EEnumWithPayloadTag Tag = static_cast(0); diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h new file mode 100644 index 00000000000..cbf6056b8a0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionBoolType.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalBool.g.h" +#include "UniqueOptionBoolType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionBoolType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalBool B; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionBoolType& Other) const + { + return B == Other.B && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionBoolType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionBoolType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionBoolType The FUniqueOptionBoolType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionBoolType& UniqueOptionBoolType) +{ + uint32 Hash = GetTypeHash(UniqueOptionBoolType.B); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionBoolType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionBoolType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionBoolType, B, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h new file mode 100644 index 00000000000..be71b22c997 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionConnectionIdType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalConnectionId.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionConnectionIdType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionConnectionIdType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalConnectionId A; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionConnectionIdType& Other) const + { + return A == Other.A && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionConnectionIdType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionConnectionIdType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionConnectionIdType The FUniqueOptionConnectionIdType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionConnectionIdType& UniqueOptionConnectionIdType) +{ + uint32 Hash = GetTypeHash(UniqueOptionConnectionIdType.A); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionConnectionIdType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionConnectionIdType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionConnectionIdType, A, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h new file mode 100644 index 00000000000..64de78df168 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI128Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt128.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionI128Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI128Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt128 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI128Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI128Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI128Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI128Type The FUniqueOptionI128Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI128Type& UniqueOptionI128Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI128Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI128Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI128Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI128Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h new file mode 100644 index 00000000000..eb3807359b2 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI16Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt16.g.h" +#include "UniqueOptionI16Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI16Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt16 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI16Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI16Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI16Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI16Type The FUniqueOptionI16Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI16Type& UniqueOptionI16Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI16Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI16Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI16Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI16Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h new file mode 100644 index 00000000000..081c7e15792 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI256Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt256.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionI256Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI256Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt256 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI256Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI256Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI256Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI256Type The FUniqueOptionI256Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI256Type& UniqueOptionI256Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI256Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI256Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI256Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI256Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h new file mode 100644 index 00000000000..2d82803202f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI32Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt32.g.h" +#include "UniqueOptionI32Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI32Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt32 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI32Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI32Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI32Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI32Type The FUniqueOptionI32Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI32Type& UniqueOptionI32Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI32Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI32Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI32Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI32Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h new file mode 100644 index 00000000000..087eeeffa33 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI64Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt64.g.h" +#include "UniqueOptionI64Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI64Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalInt64 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI64Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI64Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI64Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI64Type The FUniqueOptionI64Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI64Type& UniqueOptionI64Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI64Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI64Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI64Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI64Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h new file mode 100644 index 00000000000..2d2944586b3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionI8Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalInt8.g.h" +#include "UniqueOptionI8Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionI8Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalInt8 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalInt8 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionI8Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionI8Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionI8Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionI8Type The FUniqueOptionI8Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionI8Type& UniqueOptionI8Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionI8Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionI8Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionI8Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionI8Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h new file mode 100644 index 00000000000..f8729f9d14b --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionIdentityType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalIdentity.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionIdentityType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionIdentityType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalIdentity I; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionIdentityType& Other) const + { + return I == Other.I && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionIdentityType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionIdentityType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionIdentityType The FUniqueOptionIdentityType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionIdentityType& UniqueOptionIdentityType) +{ + uint32 Hash = GetTypeHash(UniqueOptionIdentityType.I); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionIdentityType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionIdentityType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionIdentityType, I, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h new file mode 100644 index 00000000000..6a7bfb460b3 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionStringType.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalString.g.h" +#include "UniqueOptionStringType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionStringType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalString S; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionStringType& Other) const + { + return S == Other.S && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionStringType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionStringType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionStringType The FUniqueOptionStringType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionStringType& UniqueOptionStringType) +{ + uint32 Hash = GetTypeHash(UniqueOptionStringType.S); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionStringType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionStringType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionStringType, S, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h new file mode 100644 index 00000000000..05c744c5190 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU128Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt128.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionU128Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU128Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt128 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU128Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU128Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU128Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU128Type The FUniqueOptionU128Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU128Type& UniqueOptionU128Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU128Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU128Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU128Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU128Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h new file mode 100644 index 00000000000..de5258389d9 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU16Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt16.g.h" +#include "UniqueOptionU16Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU16Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt16 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt16 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU16Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU16Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU16Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU16Type The FUniqueOptionU16Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU16Type& UniqueOptionU16Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU16Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU16Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU16Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU16Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h new file mode 100644 index 00000000000..15eb3c283f8 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU256Type.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt256.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionU256Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU256Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt256 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU256Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU256Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU256Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU256Type The FUniqueOptionU256Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU256Type& UniqueOptionU256Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU256Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU256Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU256Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU256Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h new file mode 100644 index 00000000000..beabfc2fee0 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU32Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt32.g.h" +#include "UniqueOptionU32Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU32Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt32 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt32 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU32Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU32Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU32Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU32Type The FUniqueOptionU32Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU32Type& UniqueOptionU32Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU32Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU32Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU32Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU32Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h new file mode 100644 index 00000000000..644f32aff36 --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU64Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt64.g.h" +#include "UniqueOptionU64Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU64Type +{ + GENERATED_BODY() + + // NOTE: FTestClientOptionalUInt64 field not exposed to Blueprint due to non-blueprintable elements + FTestClientOptionalUInt64 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU64Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU64Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU64Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU64Type The FUniqueOptionU64Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU64Type& UniqueOptionU64Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU64Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU64Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU64Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU64Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h new file mode 100644 index 00000000000..5c44d81577f --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionU8Type.g.h @@ -0,0 +1,50 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUInt8.g.h" +#include "UniqueOptionU8Type.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionU8Type +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUInt8 N; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionU8Type& Other) const + { + return N == Other.N && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionU8Type& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionU8Type. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionU8Type The FUniqueOptionU8Type instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionU8Type& UniqueOptionU8Type) +{ + uint32 Hash = GetTypeHash(UniqueOptionU8Type.N); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionU8Type.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionU8Type); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionU8Type, N, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h new file mode 100644 index 00000000000..ec080efd0cc --- /dev/null +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/UniqueOptionUuidType.g.h @@ -0,0 +1,51 @@ +// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE +// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. + +#pragma once +#include "CoreMinimal.h" +#include "BSATN/UESpacetimeDB.h" +#include "ModuleBindings/Optionals/TestClientOptionalUuid.g.h" +#include "Types/Builtins.h" +#include "UniqueOptionUuidType.g.generated.h" + +USTRUCT(BlueprintType) +struct TESTCLIENT_API FUniqueOptionUuidType +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + FTestClientOptionalUuid U; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpacetimeDB") + int32 Data = 0; + + FORCEINLINE bool operator==(const FUniqueOptionUuidType& Other) const + { + return U == Other.U && Data == Other.Data; + } + + FORCEINLINE bool operator!=(const FUniqueOptionUuidType& Other) const + { + return !(*this == Other); + } +}; + +/** + * Custom hash function for FUniqueOptionUuidType. + * Combines the hashes of all fields that are compared in operator==. + * @param UniqueOptionUuidType The FUniqueOptionUuidType instance to hash. + * @return The combined hash value. + */ +FORCEINLINE uint32 GetTypeHash(const FUniqueOptionUuidType& UniqueOptionUuidType) +{ + uint32 Hash = GetTypeHash(UniqueOptionUuidType.U); + Hash = HashCombine(Hash, GetTypeHash(UniqueOptionUuidType.Data)); + return Hash; +} + +namespace UE::SpacetimeDB +{ + UE_SPACETIMEDB_ENABLE_TARRAY(FUniqueOptionUuidType); + + UE_SPACETIMEDB_STRUCT(FUniqueOptionUuidType, U, Data); +} diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def index 56a099a0a11..5ea3e7b5f59 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/PrimitiveHandlerList.def @@ -40,6 +40,26 @@ M(Bool , B, false, 0xbeef, FUniqueBoolType) \ M(String, S, TEXT(""), 0xbeef, FUniqueStringType) +/* + * Macro list for unique option tables used in tests that insert then delete rows. + * Arguments: (Suffix, KeyField, SomeKeyLiteral, NoneKeyLiteral, ExpectedValue, RowStructType) + */ +#define FOREACH_UNIQUE_OPTION_PRIMITIVE(M) \ + M(U8 , N, FTestClientOptionalUInt8(0), FTestClientOptionalUInt8(), 0xbeef, FUniqueOptionU8Type) \ + M(U16 , N, FTestClientOptionalUInt16(0), FTestClientOptionalUInt16(), 0xbeef, FUniqueOptionU16Type) \ + M(U32 , N, FTestClientOptionalUInt32(0), FTestClientOptionalUInt32(), 0xbeef, FUniqueOptionU32Type) \ + M(U64 , N, FTestClientOptionalUInt64(0), FTestClientOptionalUInt64(), 0xbeef, FUniqueOptionU64Type) \ + M(U128 , N, FTestClientOptionalUInt128(FSpacetimeDBUInt128(0,0)), FTestClientOptionalUInt128(), 0xbeef, FUniqueOptionU128Type) \ + M(U256 , N, FTestClientOptionalUInt256(FSpacetimeDBUInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0))), FTestClientOptionalUInt256(), 0xbeef, FUniqueOptionU256Type) \ + M(I8 , N, FTestClientOptionalInt8(0), FTestClientOptionalInt8(), 0xbeef, FUniqueOptionI8Type) \ + M(I16 , N, FTestClientOptionalInt16(0), FTestClientOptionalInt16(), 0xbeef, FUniqueOptionI16Type) \ + M(I32 , N, FTestClientOptionalInt32(0), FTestClientOptionalInt32(), 0xbeef, FUniqueOptionI32Type) \ + M(I64 , N, FTestClientOptionalInt64(0), FTestClientOptionalInt64(), 0xbeef, FUniqueOptionI64Type) \ + M(I128 , N, FTestClientOptionalInt128(FSpacetimeDBInt128(0,0)), FTestClientOptionalInt128(), 0xbeef, FUniqueOptionI128Type) \ + M(I256 , N, FTestClientOptionalInt256(FSpacetimeDBInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0))), FTestClientOptionalInt256(), 0xbeef, FUniqueOptionI256Type) \ + M(Bool , B, FTestClientOptionalBool(false), FTestClientOptionalBool(), 0xbeef, FUniqueOptionBoolType) \ + M(String, S, FTestClientOptionalString(TEXT("")), FTestClientOptionalString(), 0xbeef, FUniqueOptionStringType) + /* * Macro list for primary-key tables used in update tests. * Arguments: (Suffix, KeyField, KeyLiteral, ExpectedValue, UpdatedValue, RowStructType) @@ -58,4 +78,4 @@ M(I128 , N, FSpacetimeDBInt128(0,0), 0xbeef, 0xbabe, FPkI128Type) \ M(I256 , N, FSpacetimeDBInt256(FSpacetimeDBUInt128(0,0),FSpacetimeDBUInt128(0,0)), 0xbeef, 0xbabe, FPkI256Type) \ M(Bool , B, false, 0xbeef, 0xbabe, FPkBoolType) \ - M(String, S, TEXT(""), 0xbeef, 0xbabe, FPkStringType) \ No newline at end of file + M(String, S, TEXT(""), 0xbeef, 0xbabe, FPkStringType) diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h index 267e28840b0..9cf7f9042a7 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/SpacetimeFullClientTests.h @@ -65,6 +65,10 @@ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertVecTest, "SpacetimeDB.TestClient.InsertV IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertOptionSomeTest, "SpacetimeDB.TestClient.InsertOptionSomeTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) /** Tests inserting none optional types. */ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertOptionNoneTest, "SpacetimeDB.TestClient.InsertOptionNoneTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) +/** Tests deleting unique option rows with Some values. */ +IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDeleteOptionSomeTest, "SpacetimeDB.TestClient.DeleteOptionSomeTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) +/** Tests deleting unique option rows with None values. */ +IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDeleteOptionNoneTest, "SpacetimeDB.TestClient.DeleteOptionNoneTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) /** Tests inserting Result Ok types. */ IMPLEMENT_SIMPLE_AUTOMATION_TEST(FInsertResultOkTest, "SpacetimeDB.TestClient.InsertResultOkTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter) diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h index 45b80ed7dac..fa8989e4ffa 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h @@ -105,6 +105,44 @@ class UDeletePrimitiveHandler : public UTestHandler UFUNCTION() void OnDeleteUniqueString(const FEventContext& Context, const FUniqueStringType& Value); }; +/** Handler used for delete-option tests. */ +UCLASS() +class UDeleteOptionHandler : public UTestHandler +{ + GENERATED_BODY() +public: + bool bUseSome = false; + + UFUNCTION() void OnInsertUniqueOptionU8(const FEventContext& Context, const FUniqueOptionU8Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU8(const FEventContext& Context, const FUniqueOptionU8Type& Value); + UFUNCTION() void OnInsertUniqueOptionU16(const FEventContext& Context, const FUniqueOptionU16Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU16(const FEventContext& Context, const FUniqueOptionU16Type& Value); + UFUNCTION() void OnInsertUniqueOptionU32(const FEventContext& Context, const FUniqueOptionU32Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU32(const FEventContext& Context, const FUniqueOptionU32Type& Value); + UFUNCTION() void OnInsertUniqueOptionU64(const FEventContext& Context, const FUniqueOptionU64Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU64(const FEventContext& Context, const FUniqueOptionU64Type& Value); + UFUNCTION() void OnInsertUniqueOptionU128(const FEventContext& Context, const FUniqueOptionU128Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU128(const FEventContext& Context, const FUniqueOptionU128Type& Value); + UFUNCTION() void OnInsertUniqueOptionU256(const FEventContext& Context, const FUniqueOptionU256Type& Value); + UFUNCTION() void OnDeleteUniqueOptionU256(const FEventContext& Context, const FUniqueOptionU256Type& Value); + UFUNCTION() void OnInsertUniqueOptionI8(const FEventContext& Context, const FUniqueOptionI8Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI8(const FEventContext& Context, const FUniqueOptionI8Type& Value); + UFUNCTION() void OnInsertUniqueOptionI16(const FEventContext& Context, const FUniqueOptionI16Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI16(const FEventContext& Context, const FUniqueOptionI16Type& Value); + UFUNCTION() void OnInsertUniqueOptionI32(const FEventContext& Context, const FUniqueOptionI32Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI32(const FEventContext& Context, const FUniqueOptionI32Type& Value); + UFUNCTION() void OnInsertUniqueOptionI64(const FEventContext& Context, const FUniqueOptionI64Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI64(const FEventContext& Context, const FUniqueOptionI64Type& Value); + UFUNCTION() void OnInsertUniqueOptionI128(const FEventContext& Context, const FUniqueOptionI128Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI128(const FEventContext& Context, const FUniqueOptionI128Type& Value); + UFUNCTION() void OnInsertUniqueOptionI256(const FEventContext& Context, const FUniqueOptionI256Type& Value); + UFUNCTION() void OnDeleteUniqueOptionI256(const FEventContext& Context, const FUniqueOptionI256Type& Value); + UFUNCTION() void OnInsertUniqueOptionBool(const FEventContext& Context, const FUniqueOptionBoolType& Value); + UFUNCTION() void OnDeleteUniqueOptionBool(const FEventContext& Context, const FUniqueOptionBoolType& Value); + UFUNCTION() void OnInsertUniqueOptionString(const FEventContext& Context, const FUniqueOptionStringType& Value); + UFUNCTION() void OnDeleteUniqueOptionString(const FEventContext& Context, const FUniqueOptionStringType& Value); +}; + /** Handler used for update-primitive tests. */ UCLASS() class UUpdatePrimitiveHandler : public UTestHandler diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h index 331e301a2da..6fd15c89318 100644 --- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h +++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h @@ -68,6 +68,23 @@ #include "ModuleBindings/Tables/UniqueI64Table.g.h" #include "ModuleBindings/Tables/UniqueI8Table.g.h" #include "ModuleBindings/Tables/UniqueIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionBoolTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionConnectionIdTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionI128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionI8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionIdentityTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionStringTable.g.h" +#include "ModuleBindings/Tables/UniqueOptionU128Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU16Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU256Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU32Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU64Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionU8Table.g.h" +#include "ModuleBindings/Tables/UniqueOptionUuidTable.g.h" #include "ModuleBindings/Tables/UniqueStringTable.g.h" #include "ModuleBindings/Tables/UniqueU128Table.g.h" #include "ModuleBindings/Tables/UniqueU16Table.g.h" @@ -100,4 +117,4 @@ #include "ModuleBindings/Tables/VecU32Table.g.h" #include "ModuleBindings/Tables/VecU64Table.g.h" #include "ModuleBindings/Tables/VecU8Table.g.h" -#include "ModuleBindings/Tables/VecUnitStructTable.g.h" \ No newline at end of file +#include "ModuleBindings/Tables/VecUnitStructTable.g.h" diff --git a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h index 3261075ff69..9f748d0d9c8 100644 --- a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h index a0235284c48..14b4b797c33 100644 --- a/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h +++ b/sdks/unreal/tests/TestProcClient/Source/TestProcClient/Public/ModuleBindings/Types/ReturnEnumType.g.h @@ -22,7 +22,7 @@ struct TESTPROCCLIENT_API FReturnEnumType public: FReturnEnumType() = default; - TVariant MessageData; + TVariant MessageData; UPROPERTY(BlueprintReadOnly) EReturnEnumTag Tag = static_cast(0); diff --git a/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h index f60aea86c1e..368932b6e26 100644 --- a/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestViewClient/Source/TestViewClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h index 76b4d6ff49c..e8cafd92658 100644 --- a/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h +++ b/sdks/unreal/tests/TestViewPkClient/Source/TestViewPkClient/Public/ModuleBindings/SpacetimeDBClient.g.h @@ -1,7 +1,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.7.0 (commit 7b2d64cdf2e66aacac74ca7aaa0b4417100d380b). +// This was generated using spacetimedb cli version 2.7.0 (commit e64e7c0c15729126f00f2742ad3535cfa24da529). #pragma once #include "CoreMinimal.h" diff --git a/sdks/unreal/tests/test.rs b/sdks/unreal/tests/test.rs index a5bb363db34..f3aa9eae311 100644 --- a/sdks/unreal/tests/test.rs +++ b/sdks/unreal/tests/test.rs @@ -179,6 +179,18 @@ fn unreal_insert_option_none() { make_test("InsertOptionNoneTest").run(); } +#[test] +#[serial(Group3)] +fn unreal_delete_option_some() { + make_test("DeleteOptionSomeTest").run(); +} + +#[test] +#[serial(Group3)] +fn unreal_delete_option_none() { + make_test("DeleteOptionNoneTest").run(); +} + #[test] #[serial(Group3)] fn unreal_insert_struct() {