diff --git a/CHANGELOG.md b/CHANGELOG.md index f4a92622b8..3f813b4d18 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ## Unreleased ### Bug fixes: + * C++: Fixed generation of getters and setters for accessors attribute -- non-trivial types use references now. * Added missing generation of conversion functions for lambdas defined in structs for Swift. * Fixed a bug related to exporting nested types defined in a type annotated as internal. diff --git a/functional-tests/functional/CMakeLists.txt b/functional-tests/functional/CMakeLists.txt index 8b94d0d9fe..df66a3102b 100644 --- a/functional-tests/functional/CMakeLists.txt +++ b/functional-tests/functional/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright (C) 2016-2019 HERE Europe B.V. +# Copyright (C) 2016-2024 HERE Europe B.V. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -135,6 +135,7 @@ feature(Structs cpp android swift dart SOURCES input/src/cpp/PlainDataStructures.cpp input/lime/Structs.lime + input/lime/Accessors.lime ) feature(StructsInTypes cpp android swift dart SOURCES diff --git a/functional-tests/functional/cpp/CMakeLists.txt b/functional-tests/functional/cpp/CMakeLists.txt index 56daee857e..361d95b8a0 100644 --- a/functional-tests/functional/cpp/CMakeLists.txt +++ b/functional-tests/functional/cpp/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright (C) 2016-2019 HERE Europe B.V. +# Copyright (C) 2016-2024 HERE Europe B.V. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -51,6 +51,7 @@ add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src EXCLUDE_FROM_ALL) set(SOURCES + tests/AccessorsTest.cpp tests/EnumTest.cpp tests/EquatableTest.cpp tests/FieldConstructorsTest.cpp diff --git a/functional-tests/functional/cpp/tests/AccessorsTest.cpp b/functional-tests/functional/cpp/tests/AccessorsTest.cpp new file mode 100644 index 0000000000..ffcaa23b0b --- /dev/null +++ b/functional-tests/functional/cpp/tests/AccessorsTest.cpp @@ -0,0 +1,195 @@ +// ------------------------------------------------------------------------------------------------- +// Copyright (C) 2024 HERE Europe B.V. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +// License-Filename: LICENSE +// +// ------------------------------------------------------------------------------------------------- + +#include "test/SomeMutableStructWithCppAccessors.h" + +#include + +#include +#include +#include +#include + +namespace test +{ + +using namespace ::testing; +using namespace test; + +namespace { + +using TrivialInt = int32_t; +using TrivialDouble = double; +using NontrivialString = std::string; +using NontrivialList = std::vector; + +SomeMutableStructWithCppAccessors get_struct() { + return SomeMutableStructWithCppAccessors { + TrivialInt{32}, + TrivialDouble{27.5}, + NontrivialString{"Some string"}, + NontrivialList{{"S1", "S2", "S3"}} + }; +} + +const SomeMutableStructWithCppAccessors get_const_struct() { + return SomeMutableStructWithCppAccessors { + TrivialInt{64}, + TrivialDouble{52.3}, + NontrivialString{"Another string"}, + NontrivialList{{"A1", "A2", "A3"}} + }; +} + +} // namespace + +TEST( AccessorsOfMutableStruct, GettingFieldsOnLvalue ) +{ + // Given an object of mutable struct with accessors. + SomeMutableStructWithCppAccessors object = get_struct(); + + // When using getters on lvalue. + const auto& int_field = object.get_trivial_int_field(); + const auto& double_field = object.get_trivial_double_field(); + const auto& string_field = object.get_nontrivial_string_field(); + const auto& list_field = object.get_nontrivial_list_field(); + + // Then access can be made. + EXPECT_EQ(TrivialInt{32}, int_field); + EXPECT_DOUBLE_EQ(TrivialDouble{27.5}, double_field); + EXPECT_EQ(NontrivialString{"Some string"}, string_field); + + const NontrivialList expected_list{"S1", "S2", "S3"}; + EXPECT_EQ(expected_list, list_field); +} + +TEST( AccessorsOfMutableStruct, GettingFieldsOnConstLvalue ) +{ + // Given const reference to object of mutable struct with accessors. + const auto& object = get_const_struct(); + + // When using getters on const lvalue. + const auto& int_field = object.get_trivial_int_field(); + const auto& double_field = object.get_trivial_double_field(); + const auto& string_field = object.get_nontrivial_string_field(); + const auto& list_field = object.get_nontrivial_list_field(); + + // Then access can be made. + EXPECT_EQ(TrivialInt{64}, int_field); + EXPECT_DOUBLE_EQ(TrivialDouble{52.3}, double_field); + EXPECT_EQ(NontrivialString{"Another string"}, string_field); + + const NontrivialList expected_list{"A1", "A2", "A3"}; + EXPECT_EQ(expected_list, list_field); +} + +TEST( AccessorsOfMutableStruct, GettingFieldsOnRvalue ) +{ + // When using getter on rvalue. + auto int_field = get_struct().get_trivial_int_field(); + auto double_field = get_struct().get_trivial_double_field(); + auto string_field = get_struct().get_nontrivial_string_field(); + auto list_field = get_struct().get_nontrivial_list_field(); + + // Then access can be made. + EXPECT_EQ(TrivialInt{32}, int_field); + EXPECT_DOUBLE_EQ(TrivialDouble{27.5}, double_field); + EXPECT_EQ(NontrivialString{"Some string"}, string_field); + + const NontrivialList expected_list{"S1", "S2", "S3"}; + EXPECT_EQ(expected_list, list_field); +} + +TEST( AccessorsOfMutableStruct, GettingFieldsOnConstRvalue ) +{ + // When using getters on const rvalue. + auto int_field = get_const_struct().get_trivial_int_field(); + auto double_field = get_const_struct().get_trivial_double_field(); + auto string_field = get_const_struct().get_nontrivial_string_field(); + auto list_field = get_const_struct().get_nontrivial_list_field(); + + // Then access can be made. + EXPECT_EQ(TrivialInt{64}, int_field); + EXPECT_DOUBLE_EQ(TrivialDouble{52.3}, double_field); + EXPECT_EQ(NontrivialString{"Another string"}, string_field); + + const NontrivialList expected_list{"A1", "A2", "A3"}; + EXPECT_EQ(expected_list, list_field); +} + +TEST( AccessorsOfMutableStruct, PreconditionsForNontrivialGetters ) +{ + // String getters. + using LvalueStringGetterRetT = decltype(std::declval().get_nontrivial_string_field()); + static_assert(std::is_same_v, "String getter shall return const ref when called on L-value"); + + using ConstLvalueStringGetterRetT = decltype(std::declval().get_nontrivial_string_field()); + static_assert(std::is_same_v, "String getter shall return const ref when called on const L-value"); + + using RvalueStringGetterRetT = decltype(std::declval().get_nontrivial_string_field()); + static_assert(std::is_same_v, "String getter shall return r-ref when called on R-value"); + + using ConstRvalueStringGetterRetT = decltype(std::declval().get_nontrivial_string_field()); + static_assert(std::is_same_v, "String getter shall return const r-ref when called on const R-value"); + + // List getters. + using LvalueListGetterRetT = decltype(std::declval().get_nontrivial_list_field()); + static_assert(std::is_same_v&, LvalueListGetterRetT>, "List getter shall return const l-ref when called on L-value"); + + using ConstLvalueListGetterRetT = decltype(std::declval().get_nontrivial_list_field()); + static_assert(std::is_same_v&, ConstLvalueListGetterRetT>, "List getter shall return const l-ref when called on const L-value"); + + using RvalueListGetterRetT = decltype(std::declval().get_nontrivial_list_field()); + static_assert(std::is_same_v&&, RvalueListGetterRetT>, "List getter shall return r-ref when called on R-value"); + + using ConstRvalueListGetterRetT = decltype(std::declval().get_nontrivial_list_field()); + static_assert(std::is_same_v&&, ConstRvalueListGetterRetT>, "List getter shall return const r-ref when called on const R-value"); +} + +TEST( AccessorsOfMutableStruct, PreconditionsForTrivialGetters ) +{ + // Int getter. + using LvalueIntGetterRetT = decltype(std::declval().get_trivial_int_field()); + static_assert(std::is_same_v, "int getter shall always return by-value"); + + using ConstLvalueIntGetterRetT = decltype(std::declval().get_trivial_int_field()); + static_assert(std::is_same_v, "int getter shall always return by-value"); + + using RvalueIntGetterRetT = decltype(std::declval().get_trivial_int_field()); + static_assert(std::is_same_v, "int getter shall always return by-value"); + + using ConstRvalueIntGetterRetT = decltype(std::declval().get_trivial_int_field()); + static_assert(std::is_same_v, "int getter shall always return by-value"); + + // Double getter. + using LvalueDoubleGetterRetT = decltype(std::declval().get_trivial_double_field()); + static_assert(std::is_same_v, "double getter shall always return by-value"); + + using ConstLvalueDoubleGetterRetT = decltype(std::declval().get_trivial_double_field()); + static_assert(std::is_same_v, "double getter shall always return by-value"); + + using RvalueDoubleGetterRetT = decltype(std::declval().get_trivial_double_field()); + static_assert(std::is_same_v, "double getter shall always return by-value"); + + using ConstRvalueDoubleGetterRetT = decltype(std::declval().get_trivial_double_field()); + static_assert(std::is_same_v, "double getter shall always return by-value"); +} + +} // test diff --git a/functional-tests/functional/input/lime/Accessors.lime b/functional-tests/functional/input/lime/Accessors.lime new file mode 100644 index 0000000000..a16d0d4cb7 --- /dev/null +++ b/functional-tests/functional/input/lime/Accessors.lime @@ -0,0 +1,27 @@ +# Copyright (C) 2024 HERE Europe B.V. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# License-Filename: LICENSE + +package test + +@Cpp(Accessors) +struct SomeMutableStructWithCppAccessors { + trivialIntField: Int + trivialDoubleField: Double + + nontrivialStringField: String + nontrivialListField: List +} diff --git a/gluecodium/src/main/resources/templates/cpp/CppStruct.mustache b/gluecodium/src/main/resources/templates/cpp/CppStruct.mustache index ac0483ff1c..5a7493abfe 100644 --- a/gluecodium/src/main/resources/templates/cpp/CppStruct.mustache +++ b/gluecodium/src/main/resources/templates/cpp/CppStruct.mustache @@ -1,6 +1,6 @@ {{!! ! - ! Copyright (C) 2016-2020 HERE Europe B.V. + ! Copyright (C) 2016-2024 HERE Europe B.V. ! ! Licensed under the Apache License, Version 2.0 (the "License"); ! you may not use this file except in compliance with the License. @@ -51,10 +51,21 @@ public: }}{{#if attributes.cpp.accessors}} {{#set structElement=this}}{{#fields}} {{prefixPartial "cpp/CppFieldDoc" " "}} - {{resolveName typeRef}} {{resolveName this "" "getter"}}( ) const { return {{resolveName}}; }{{!! + {{#ifPredicate typeRef "needsRefSuffix"}}const {{resolveName typeRef}}&{{!! +}} {{resolveName this "" "getter"}}( ) const & { return {{resolveName}}; } + {{resolveName typeRef}}&& {{resolveName this "" "getter"}}( ) && { return std::move({{resolveName}}); } + const {{resolveName typeRef}}&& {{resolveName this "" "getter"}}( ) const && { return std::move({{resolveName}}); }{{/ifPredicate}}{{!! +}}{{#unlessPredicate typeRef "needsRefSuffix"}}{{resolveName typeRef}}{{!! +}} {{resolveName this "" "getter"}}( ) const { return {{resolveName}}; }{{/unlessPredicate}}{{!! }}{{#unless structElement.attributes.immutable}} {{prefixPartial "cpp/CppFieldDoc" " "}} - void {{resolveName this "" "setter"}}( {{resolveName typeRef}} value_ ) { {{resolveName}} = value_; }{{!! +{{#ifPredicate typeRef "needsRefSuffix"}}{{!! +}} void {{resolveName this "" "setter"}}( const {{resolveName typeRef}}& value_ ) { {{resolveName}} = value_; } + void {{resolveName this "" "setter"}}( {{resolveName typeRef}}&& value_ ) { {{resolveName}} = std::move(value_); }{{!! +}}{{/ifPredicate}}{{!! +}}{{#unlessPredicate typeRef "needsRefSuffix"}}{{!! +}} void {{resolveName this "" "setter"}}( {{resolveName typeRef}} value_ ) { {{resolveName}} = value_; }{{!! +}}{{/unlessPredicate}}{{!! }}{{/unless}} {{/fields}}{{/set}} diff --git a/gluecodium/src/main/resources/templates/cpp/StructHashImpl.mustache b/gluecodium/src/main/resources/templates/cpp/StructHashImpl.mustache index 5fec505fdc..ec8b4b567d 100644 --- a/gluecodium/src/main/resources/templates/cpp/StructHashImpl.mustache +++ b/gluecodium/src/main/resources/templates/cpp/StructHashImpl.mustache @@ -1,6 +1,6 @@ {{!! ! - ! Copyright (C) 2016-2020 HERE Europe B.V. + ! Copyright (C) 2016-2024 HERE Europe B.V. ! ! Licensed under the Apache License, Version 2.0 (the "License"); ! you may not use this file except in compliance with the License. @@ -23,8 +23,8 @@ hash< {{resolveName "FQN"}} >::operator( )( const {{resolveName "FQN"}}& t ) con { size_t hash_value = 43; {{#if attributes.cpp.accessors}} - {{#resolveName "FQN"}}{{#set structName=this}}{{#fields}}hash_value = (hash_value ^ {{>common/InternalNamespace}}hash< decltype({{!! - }}std::declval<{{structName}}>().{{resolveName this "" "getter"}}()) >()(t.{{resolveName this "" "getter"}}())) << 1; + {{#resolveName "FQN"}}{{#set structName=this}}{{#fields}}hash_value = (hash_value ^ {{>common/InternalNamespace}}hash< std::remove_cv_t< std::remove_reference_t< decltype({{!! + }}std::declval<{{structName}}>().{{resolveName this "" "getter"}}()) > > >()(t.{{resolveName this "" "getter"}}())) << 1; {{/fields}}{{/set}}{{/resolveName}} {{/if}}{{#unless attributes.cpp.accessors}} {{#fields}} diff --git a/gluecodium/src/test/resources/smoke/equatable/output/cpp/src/smoke/EquatableStructWithAccessors.cpp b/gluecodium/src/test/resources/smoke/equatable/output/cpp/src/smoke/EquatableStructWithAccessors.cpp index 24a0371a3d..54debc3acc 100644 --- a/gluecodium/src/test/resources/smoke/equatable/output/cpp/src/smoke/EquatableStructWithAccessors.cpp +++ b/gluecodium/src/test/resources/smoke/equatable/output/cpp/src/smoke/EquatableStructWithAccessors.cpp @@ -1,33 +1,43 @@ // ------------------------------------------------------------------------------------------------- // + // // ------------------------------------------------------------------------------------------------- + #include "smoke/EquatableStructWithAccessors.h" #include + namespace smoke { + EquatableStructWithAccessors::EquatableStructWithAccessors( ) : foo_field{ } { } + EquatableStructWithAccessors::EquatableStructWithAccessors( ::std::string foo_field ) : foo_field( std::move( foo_field ) ) { } + bool EquatableStructWithAccessors::operator==( const EquatableStructWithAccessors& rhs ) const { return foo_field == rhs.foo_field; } + bool EquatableStructWithAccessors::operator!=( const EquatableStructWithAccessors& rhs ) const { return !( *this == rhs ); } + + } + namespace gluecodium { std::size_t hash< ::smoke::EquatableStructWithAccessors >::operator( )( const ::smoke::EquatableStructWithAccessors& t ) const { size_t hash_value = 43; - hash_value = (hash_value ^ ::gluecodium::hash< decltype(std::declval<::smoke::EquatableStructWithAccessors>().get_foo_field()) >()(t.get_foo_field())) << 1; + hash_value = (hash_value ^ ::gluecodium::hash< std::remove_cv_t< std::remove_reference_t< decltype(std::declval<::smoke::EquatableStructWithAccessors>().get_foo_field()) > > >()(t.get_foo_field())) << 1; return hash_value; } } diff --git a/gluecodium/src/test/resources/smoke/structs/input/Structs.lime b/gluecodium/src/test/resources/smoke/structs/input/Structs.lime index d85e3a69eb..c17ac4b0cc 100644 --- a/gluecodium/src/test/resources/smoke/structs/input/Structs.lime +++ b/gluecodium/src/test/resources/smoke/structs/input/Structs.lime @@ -1,4 +1,4 @@ -# Copyright (C) 2016-2019 HERE Europe B.V. +# Copyright (C) 2016-2024 HERE Europe B.V. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -57,11 +57,21 @@ class Structs { @Cpp(Accessors) @Immutable struct ImmutableStructWithCppAccessors { - stringField: String + trivialIntField: Int + trivialDoubleField: Double + + nontrivialStringField: String + nontrivialPointField: Point + nontrivialOptionalPoint: Point? } @Cpp(Accessors) struct MutableStructWithCppAccessors { - stringField: String + trivialIntField: Int + trivialDoubleField: Double + + nontrivialStringField: String + nontrivialPointField: Point + nontrivialOptionalPoint: Point? } enum FooBar { diff --git a/gluecodium/src/test/resources/smoke/structs/output/android/com/example/smoke/Structs.java b/gluecodium/src/test/resources/smoke/structs/output/android/com/example/smoke/Structs.java index a8604600db..f567b90d33 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/android/com/example/smoke/Structs.java +++ b/gluecodium/src/test/resources/smoke/structs/output/android/com/example/smoke/Structs.java @@ -6,6 +6,7 @@ package com.example.smoke; import android.support.annotation.NonNull; +import android.support.annotation.Nullable; import com.example.NativeBase; import java.util.List; @@ -121,22 +122,50 @@ public StructWithArrayOfImmutable(@NonNull final List ar } public static final class ImmutableStructWithCppAccessors { + public final int trivialIntField; + public final double trivialDoubleField; @NonNull - public final String stringField; + public final String nontrivialStringField; + @NonNull + public final Structs.Point nontrivialPointField; + @Nullable + public final Structs.Point nontrivialOptionalPoint; + + public ImmutableStructWithCppAccessors(final int trivialIntField, final double trivialDoubleField, @NonNull final String nontrivialStringField, @NonNull final Structs.Point nontrivialPointField) { + this.trivialIntField = trivialIntField; + this.trivialDoubleField = trivialDoubleField; + this.nontrivialStringField = nontrivialStringField; + this.nontrivialPointField = nontrivialPointField; + this.nontrivialOptionalPoint = null; + } - public ImmutableStructWithCppAccessors(@NonNull final String stringField) { - this.stringField = stringField; + public ImmutableStructWithCppAccessors(final int trivialIntField, final double trivialDoubleField, @NonNull final String nontrivialStringField, @NonNull final Structs.Point nontrivialPointField, @Nullable final Structs.Point nontrivialOptionalPoint) { + this.trivialIntField = trivialIntField; + this.trivialDoubleField = trivialDoubleField; + this.nontrivialStringField = nontrivialStringField; + this.nontrivialPointField = nontrivialPointField; + this.nontrivialOptionalPoint = nontrivialOptionalPoint; } } public static final class MutableStructWithCppAccessors { + public int trivialIntField; + public double trivialDoubleField; @NonNull - public String stringField; - - public MutableStructWithCppAccessors(@NonNull final String stringField) { - this.stringField = stringField; + public String nontrivialStringField; + @NonNull + public Structs.Point nontrivialPointField; + @Nullable + public Structs.Point nontrivialOptionalPoint; + + public MutableStructWithCppAccessors(final int trivialIntField, final double trivialDoubleField, @NonNull final String nontrivialStringField, @NonNull final Structs.Point nontrivialPointField) { + this.trivialIntField = trivialIntField; + this.trivialDoubleField = trivialDoubleField; + this.nontrivialStringField = nontrivialStringField; + this.nontrivialPointField = nontrivialPointField; + this.nontrivialOptionalPoint = null; } diff --git a/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_ImmutableStructWithCppAccessors__Conversion.cpp b/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_ImmutableStructWithCppAccessors__Conversion.cpp index c7a7debefd..9d59b82000 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_ImmutableStructWithCppAccessors__Conversion.cpp +++ b/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_ImmutableStructWithCppAccessors__Conversion.cpp @@ -18,13 +18,35 @@ ::smoke::Structs::ImmutableStructWithCppAccessors convert_from_jni(JNIEnv* _jenv, const JniReference& _jinput, TypeId<::smoke::Structs::ImmutableStructWithCppAccessors>) { - ::std::string n_string_field = ::gluecodium::jni::get_field_value( + int32_t n_trivial_int_field = ::gluecodium::jni::get_field_value( _jenv, _jinput, - "stringField", + "trivialIntField", + TypeId{} ); + + double n_trivial_double_field = ::gluecodium::jni::get_field_value( + _jenv, + _jinput, + "trivialDoubleField", + TypeId{} ); + + ::std::string n_nontrivial_string_field = ::gluecodium::jni::get_field_value( + _jenv, + _jinput, + "nontrivialStringField", TypeId<::std::string>{} ); - return ::smoke::Structs::ImmutableStructWithCppAccessors(std::move(n_string_field)); + ::smoke::Structs::Point n_nontrivial_point_field = convert_from_jni( + _jenv, + ::gluecodium::jni::get_object_field_value(_jenv, _jinput, "nontrivialPointField", "Lcom/example/smoke/Structs$Point;"), + TypeId<::smoke::Structs::Point>{} ); + + std::optional< ::smoke::Structs::Point > n_nontrivial_optional_point = convert_from_jni( + _jenv, + ::gluecodium::jni::get_object_field_value(_jenv, _jinput, "nontrivialOptionalPoint", "Lcom/example/smoke/Structs$Point;"), + TypeId>{} ); + + return ::smoke::Structs::ImmutableStructWithCppAccessors(std::move(n_trivial_int_field), std::move(n_trivial_double_field), std::move(n_nontrivial_string_field), std::move(n_nontrivial_point_field), std::move(n_nontrivial_optional_point)); } std::optional<::smoke::Structs::ImmutableStructWithCppAccessors> @@ -43,7 +65,17 @@ convert_to_jni(JNIEnv* _jenv, const ::smoke::Structs::ImmutableStructWithCppAcce auto& javaClass = CachedJavaClass<::smoke::Structs::ImmutableStructWithCppAccessors>::java_class; auto _jresult = ::gluecodium::jni::alloc_object(_jenv, javaClass); - ::gluecodium::jni::set_field_value(_jenv, _jresult, "stringField", _ninput.get_string_field()); + ::gluecodium::jni::set_field_value(_jenv, _jresult, "trivialIntField", _ninput.get_trivial_int_field()); + + ::gluecodium::jni::set_field_value(_jenv, _jresult, "trivialDoubleField", _ninput.get_trivial_double_field()); + + ::gluecodium::jni::set_field_value(_jenv, _jresult, "nontrivialStringField", _ninput.get_nontrivial_string_field()); + + auto jnontrivial_point_field = convert_to_jni(_jenv, _ninput.get_nontrivial_point_field()); + ::gluecodium::jni::set_object_field_value(_jenv, _jresult, "nontrivialPointField", "Lcom/example/smoke/Structs$Point;", jnontrivial_point_field); + + auto jnontrivial_optional_point = convert_to_jni(_jenv, _ninput.get_nontrivial_optional_point()); + ::gluecodium::jni::set_object_field_value(_jenv, _jresult, "nontrivialOptionalPoint", "Lcom/example/smoke/Structs$Point;", jnontrivial_optional_point); return _jresult; } diff --git a/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_MutableStructWithCppAccessors__Conversion.cpp b/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_MutableStructWithCppAccessors__Conversion.cpp index 481bbe288f..168ff7ed09 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_MutableStructWithCppAccessors__Conversion.cpp +++ b/gluecodium/src/test/resources/smoke/structs/output/android/jni/com_example_smoke_Structs_MutableStructWithCppAccessors__Conversion.cpp @@ -18,12 +18,34 @@ ::smoke::Structs::MutableStructWithCppAccessors convert_from_jni(JNIEnv* _jenv, const JniReference& _jinput, TypeId<::smoke::Structs::MutableStructWithCppAccessors>) { ::smoke::Structs::MutableStructWithCppAccessors _nout{}; - ::std::string n_string_field = ::gluecodium::jni::get_field_value( + int32_t n_trivial_int_field = ::gluecodium::jni::get_field_value( _jenv, _jinput, - "stringField", + "trivialIntField", + TypeId{} ); + _nout.set_trivial_int_field(n_trivial_int_field); + double n_trivial_double_field = ::gluecodium::jni::get_field_value( + _jenv, + _jinput, + "trivialDoubleField", + TypeId{} ); + _nout.set_trivial_double_field(n_trivial_double_field); + ::std::string n_nontrivial_string_field = ::gluecodium::jni::get_field_value( + _jenv, + _jinput, + "nontrivialStringField", TypeId<::std::string>{} ); - _nout.set_string_field(n_string_field); + _nout.set_nontrivial_string_field(n_nontrivial_string_field); + ::smoke::Structs::Point n_nontrivial_point_field = convert_from_jni( + _jenv, + ::gluecodium::jni::get_object_field_value(_jenv, _jinput, "nontrivialPointField", "Lcom/example/smoke/Structs$Point;"), + TypeId<::smoke::Structs::Point>{} ); + _nout.set_nontrivial_point_field(n_nontrivial_point_field); + std::optional< ::smoke::Structs::Point > n_nontrivial_optional_point = convert_from_jni( + _jenv, + ::gluecodium::jni::get_object_field_value(_jenv, _jinput, "nontrivialOptionalPoint", "Lcom/example/smoke/Structs$Point;"), + TypeId>{} ); + _nout.set_nontrivial_optional_point(n_nontrivial_optional_point); return _nout; } @@ -43,7 +65,17 @@ convert_to_jni(JNIEnv* _jenv, const ::smoke::Structs::MutableStructWithCppAccess auto& javaClass = CachedJavaClass<::smoke::Structs::MutableStructWithCppAccessors>::java_class; auto _jresult = ::gluecodium::jni::alloc_object(_jenv, javaClass); - ::gluecodium::jni::set_field_value(_jenv, _jresult, "stringField", _ninput.get_string_field()); + ::gluecodium::jni::set_field_value(_jenv, _jresult, "trivialIntField", _ninput.get_trivial_int_field()); + + ::gluecodium::jni::set_field_value(_jenv, _jresult, "trivialDoubleField", _ninput.get_trivial_double_field()); + + ::gluecodium::jni::set_field_value(_jenv, _jresult, "nontrivialStringField", _ninput.get_nontrivial_string_field()); + + auto jnontrivial_point_field = convert_to_jni(_jenv, _ninput.get_nontrivial_point_field()); + ::gluecodium::jni::set_object_field_value(_jenv, _jresult, "nontrivialPointField", "Lcom/example/smoke/Structs$Point;", jnontrivial_point_field); + + auto jnontrivial_optional_point = convert_to_jni(_jenv, _ninput.get_nontrivial_optional_point()); + ::gluecodium::jni::set_object_field_value(_jenv, _jresult, "nontrivialOptionalPoint", "Lcom/example/smoke/Structs$Point;", jnontrivial_optional_point); return _jresult; } diff --git a/gluecodium/src/test/resources/smoke/structs/output/cbridge/include/smoke/cbridge_Structs.h b/gluecodium/src/test/resources/smoke/structs/output/cbridge/include/smoke/cbridge_Structs.h index 1c63ac5858..68375ec1a2 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/cbridge/include/smoke/cbridge_Structs.h +++ b/gluecodium/src/test/resources/smoke/structs/output/cbridge/include/smoke/cbridge_Structs.h @@ -1,32 +1,50 @@ // + // + #pragma once + #ifdef __cplusplus extern "C" { #endif + #include "cbridge/include/BaseHandle.h" #include "cbridge/include/Export.h" #include #include + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Point_create_handle(double x, double y); _GLUECODIUM_C_EXPORT void smoke_Structs_Point_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Point_create_optional_handle(double x, double y); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Point_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_Point_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT double smoke_Structs_Point_x_get(_baseRef handle); _GLUECODIUM_C_EXPORT double smoke_Structs_Point_y_get(_baseRef handle); + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Line_create_handle(_baseRef a, _baseRef b); _GLUECODIUM_C_EXPORT void smoke_Structs_Line_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Line_create_optional_handle(_baseRef a, _baseRef b); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Line_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_Line_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Line_a_get(_baseRef handle); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_Line_b_get(_baseRef handle); + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_create_handle(int8_t int8Field, uint8_t uint8Field, int16_t int16Field, uint16_t uint16Field, int32_t int32Field, uint32_t uint32Field, int64_t int64Field, uint64_t uint64Field, float floatField, double doubleField, _baseRef stringField, bool booleanField, _baseRef bytesField, _baseRef pointField); _GLUECODIUM_C_EXPORT void smoke_Structs_AllTypesStruct_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_create_optional_handle(int8_t int8Field, uint8_t uint8Field, int16_t int16Field, uint16_t uint16Field, int32_t int32Field, uint32_t uint32Field, int64_t int64Field, uint64_t uint64Field, float floatField, double doubleField, _baseRef stringField, bool booleanField, _baseRef bytesField, _baseRef pointField); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_AllTypesStruct_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT int8_t smoke_Structs_AllTypesStruct_int8Field_get(_baseRef handle); _GLUECODIUM_C_EXPORT uint8_t smoke_Structs_AllTypesStruct_uint8Field_get(_baseRef handle); _GLUECODIUM_C_EXPORT int16_t smoke_Structs_AllTypesStruct_int16Field_get(_baseRef handle); @@ -41,45 +59,93 @@ _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_stringField_get(_base _GLUECODIUM_C_EXPORT bool smoke_Structs_AllTypesStruct_booleanField_get(_baseRef handle); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_bytesField_get(_baseRef handle); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_AllTypesStruct_pointField_get(_baseRef handle); + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_NestingImmutableStruct_create_handle(_baseRef structField); _GLUECODIUM_C_EXPORT void smoke_Structs_NestingImmutableStruct_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_NestingImmutableStruct_create_optional_handle(_baseRef structField); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_NestingImmutableStruct_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_NestingImmutableStruct_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_NestingImmutableStruct_structField_get(_baseRef handle); + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_DoubleNestingImmutableStruct_create_handle(_baseRef nestingStructField); _GLUECODIUM_C_EXPORT void smoke_Structs_DoubleNestingImmutableStruct_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_DoubleNestingImmutableStruct_create_optional_handle(_baseRef nestingStructField); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_DoubleNestingImmutableStruct_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_DoubleNestingImmutableStruct_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_DoubleNestingImmutableStruct_nestingStructField_get(_baseRef handle); + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_StructWithArrayOfImmutable_create_handle(_baseRef arrayField); _GLUECODIUM_C_EXPORT void smoke_Structs_StructWithArrayOfImmutable_release_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_StructWithArrayOfImmutable_create_optional_handle(_baseRef arrayField); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_StructWithArrayOfImmutable_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_StructWithArrayOfImmutable_release_optional_handle(_baseRef handle); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_StructWithArrayOfImmutable_arrayField_get(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_create_handle(_baseRef stringField); + + + +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint); _GLUECODIUM_C_EXPORT void smoke_Structs_ImmutableStructWithCppAccessors_release_handle(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(_baseRef stringField); + +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_ImmutableStructWithCppAccessors_release_optional_handle(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_stringField_get(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_create_handle(_baseRef stringField); + +_GLUECODIUM_C_EXPORT int32_t smoke_Structs_ImmutableStructWithCppAccessors_trivialIntField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT double smoke_Structs_ImmutableStructWithCppAccessors_trivialDoubleField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialStringField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialPointField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialOptionalPoint_get(_baseRef handle); + + + +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint); _GLUECODIUM_C_EXPORT void smoke_Structs_MutableStructWithCppAccessors_release_handle(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(_baseRef stringField); + +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_unwrap_optional_handle(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_MutableStructWithCppAccessors_release_optional_handle(_baseRef handle); -_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_stringField_get(_baseRef handle); + +_GLUECODIUM_C_EXPORT int32_t smoke_Structs_MutableStructWithCppAccessors_trivialIntField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT double smoke_Structs_MutableStructWithCppAccessors_trivialDoubleField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialStringField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialPointField_get(_baseRef handle); +_GLUECODIUM_C_EXPORT _baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialOptionalPoint_get(_baseRef handle); + + + + _GLUECODIUM_C_EXPORT void smoke_Structs_release_handle(_baseRef handle); _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_copy_handle(_baseRef handle); _GLUECODIUM_C_EXPORT const void* smoke_Structs_get_swift_object_from_wrapper_cache(_baseRef handle); _GLUECODIUM_C_EXPORT void smoke_Structs_cache_swift_object_wrapper(_baseRef handle, const void* swift_pointer); _GLUECODIUM_C_EXPORT void smoke_Structs_remove_swift_object_from_wrapper_cache(_baseRef handle); + + + + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_swapPointCoordinates(_baseRef input); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_returnAllTypesStruct(_baseRef input); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_createPoint(double x, double y); + _GLUECODIUM_C_EXPORT _baseRef smoke_Structs_modifyAllTypesStruct(_baseRef input); + + + + #ifdef __cplusplus } #endif diff --git a/gluecodium/src/test/resources/smoke/structs/output/cbridge/src/smoke/cbridge_Structs.cpp b/gluecodium/src/test/resources/smoke/structs/output/cbridge/src/smoke/cbridge_Structs.cpp index ca6d626165..bb386276ce 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/cbridge/src/smoke/cbridge_Structs.cpp +++ b/gluecodium/src/test/resources/smoke/structs/output/cbridge/src/smoke/cbridge_Structs.cpp @@ -1,5 +1,7 @@ // + // + #include "cbridge/include/smoke/cbridge_Structs.h" #include "cbridge/include/ByteArrayHandle.h" #include "cbridge/include/StringHandle.h" @@ -15,68 +17,95 @@ #include #include #include + void smoke_Structs_release_handle(_baseRef handle) { delete get_pointer<::std::shared_ptr< ::smoke::Structs >>(handle); } + _baseRef smoke_Structs_copy_handle(_baseRef handle) { return handle ? reinterpret_cast<_baseRef>(checked_pointer_copy(*get_pointer<::std::shared_ptr< ::smoke::Structs >>(handle))) : 0; } + const void* smoke_Structs_get_swift_object_from_wrapper_cache(_baseRef handle) { return handle ? ::gluecodium::get_wrapper_cache().get_cached_wrapper(get_pointer<::std::shared_ptr< ::smoke::Structs >>(handle)->get()) : nullptr; } + void smoke_Structs_cache_swift_object_wrapper(_baseRef handle, const void* swift_pointer) { if (!handle) return; ::gluecodium::get_wrapper_cache().cache_wrapper(get_pointer<::std::shared_ptr< ::smoke::Structs >>(handle)->get(), swift_pointer); } + void smoke_Structs_remove_swift_object_from_wrapper_cache(_baseRef handle) { if (!::gluecodium::WrapperCache::is_alive) return; ::gluecodium::get_wrapper_cache().remove_cached_wrapper(get_pointer<::std::shared_ptr< ::smoke::Structs >>(handle)->get()); } + + + + + _baseRef smoke_Structs_swapPointCoordinates(_baseRef input) { return Conversion<::smoke::Structs::Point>::toBaseRef(::smoke::Structs::swap_point_coordinates(Conversion<::smoke::Structs::Point>::toCpp(input))); } + + _baseRef smoke_Structs_returnAllTypesStruct(_baseRef input) { return Conversion<::smoke::Structs::AllTypesStruct>::toBaseRef(::smoke::Structs::return_all_types_struct(Conversion<::smoke::Structs::AllTypesStruct>::toCpp(input))); } + + _baseRef smoke_Structs_createPoint(double x, double y) { return Conversion<::smoke::TypeCollection::Point>::toBaseRef(::smoke::Structs::create_point(x, y)); } + + _baseRef smoke_Structs_modifyAllTypesStruct(_baseRef input) { return Conversion<::smoke::TypeCollection::AllTypesStruct>::toBaseRef(::smoke::Structs::modify_all_types_struct(Conversion<::smoke::TypeCollection::AllTypesStruct>::toCpp(input))); } + + + + _baseRef smoke_Structs_Point_create_handle( double x, double y ) { ::smoke::Structs::Point* _struct = new ( ::std::nothrow ) ::smoke::Structs::Point(); _struct->x = x; _struct->y = y; + return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_Point_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::Point>( handle ); } + _baseRef smoke_Structs_Point_create_optional_handle(double x, double y) { auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::Point>( ::smoke::Structs::Point( ) ); (*_struct)->x = x; (*_struct)->y = y; + return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_Point_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_Point_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + double smoke_Structs_Point_x_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return struct_pointer->x; @@ -85,35 +114,45 @@ double smoke_Structs_Point_y_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return struct_pointer->y; } + + + _baseRef smoke_Structs_Line_create_handle( _baseRef a, _baseRef b ) { ::smoke::Structs::Line* _struct = new ( ::std::nothrow ) ::smoke::Structs::Line(); _struct->a = Conversion<::smoke::Structs::Point>::toCpp( a ); _struct->b = Conversion<::smoke::Structs::Point>::toCpp( b ); + return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_Line_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::Line>( handle ); } + _baseRef smoke_Structs_Line_create_optional_handle(_baseRef a, _baseRef b) { auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::Line>( ::smoke::Structs::Line( ) ); (*_struct)->a = Conversion<::smoke::Structs::Point>::toCpp( a ); (*_struct)->b = Conversion<::smoke::Structs::Point>::toCpp( b ); + return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_Line_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_Line_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + _baseRef smoke_Structs_Line_a_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::smoke::Structs::Point>::toBaseRef(struct_pointer->a); @@ -122,9 +161,13 @@ _baseRef smoke_Structs_Line_b_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::smoke::Structs::Point>::toBaseRef(struct_pointer->b); } + + + _baseRef smoke_Structs_AllTypesStruct_create_handle( int8_t int8Field, uint8_t uint8Field, int16_t int16Field, uint16_t uint16Field, int32_t int32Field, uint32_t uint32Field, int64_t int64Field, uint64_t uint64Field, float floatField, double doubleField, _baseRef stringField, bool booleanField, _baseRef bytesField, _baseRef pointField ) { + auto _int8Field = int8Field; auto _uint8Field = uint8Field; auto _int16Field = int16Field; @@ -142,14 +185,17 @@ smoke_Structs_AllTypesStruct_create_handle( int8_t int8Field, uint8_t uint8Field ::smoke::Structs::AllTypesStruct* _struct = new ( ::std::nothrow ) ::smoke::Structs::AllTypesStruct( _int8Field, _uint8Field, _int16Field, _uint16Field, _int32Field, _uint32Field, _int64Field, _uint64Field, _floatField, _doubleField, _stringField, _booleanField, _bytesField, _pointField ); return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_AllTypesStruct_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::AllTypesStruct>( handle ); } + _baseRef smoke_Structs_AllTypesStruct_create_optional_handle(int8_t int8Field, uint8_t uint8Field, int16_t int16Field, uint16_t uint16Field, int32_t int32Field, uint32_t uint32Field, int64_t int64Field, uint64_t uint64Field, float floatField, double doubleField, _baseRef stringField, bool booleanField, _baseRef bytesField, _baseRef pointField) { + auto _int8Field = int8Field; auto _uint8Field = uint8Field; auto _int16Field = int16Field; @@ -167,14 +213,17 @@ smoke_Structs_AllTypesStruct_create_optional_handle(int8_t int8Field, uint8_t ui auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::AllTypesStruct>( ::smoke::Structs::AllTypesStruct( _int8Field, _uint8Field, _int16Field, _uint16Field, _int32Field, _uint32Field, _int64Field, _uint64Field, _floatField, _doubleField, _stringField, _booleanField, _bytesField, _pointField ) ); return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_AllTypesStruct_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_AllTypesStruct_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + int8_t smoke_Structs_AllTypesStruct_int8Field_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return struct_pointer->int8_field; @@ -231,158 +280,261 @@ _baseRef smoke_Structs_AllTypesStruct_pointField_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::smoke::Structs::Point>::toBaseRef(struct_pointer->point_field); } + + + _baseRef smoke_Structs_NestingImmutableStruct_create_handle( _baseRef structField ) { + auto _structField = Conversion<::smoke::Structs::AllTypesStruct>::toCpp( structField ); ::smoke::Structs::NestingImmutableStruct* _struct = new ( ::std::nothrow ) ::smoke::Structs::NestingImmutableStruct( _structField ); return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_NestingImmutableStruct_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::NestingImmutableStruct>( handle ); } + _baseRef smoke_Structs_NestingImmutableStruct_create_optional_handle(_baseRef structField) { + auto _structField = Conversion<::smoke::Structs::AllTypesStruct>::toCpp( structField ); auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::NestingImmutableStruct>( ::smoke::Structs::NestingImmutableStruct( _structField ) ); return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_NestingImmutableStruct_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_NestingImmutableStruct_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + _baseRef smoke_Structs_NestingImmutableStruct_structField_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::smoke::Structs::AllTypesStruct>::toBaseRef(struct_pointer->struct_field); } + + + _baseRef smoke_Structs_DoubleNestingImmutableStruct_create_handle( _baseRef nestingStructField ) { + auto _nestingStructField = Conversion<::smoke::Structs::NestingImmutableStruct>::toCpp( nestingStructField ); ::smoke::Structs::DoubleNestingImmutableStruct* _struct = new ( ::std::nothrow ) ::smoke::Structs::DoubleNestingImmutableStruct( _nestingStructField ); return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_DoubleNestingImmutableStruct_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::DoubleNestingImmutableStruct>( handle ); } + _baseRef smoke_Structs_DoubleNestingImmutableStruct_create_optional_handle(_baseRef nestingStructField) { + auto _nestingStructField = Conversion<::smoke::Structs::NestingImmutableStruct>::toCpp( nestingStructField ); auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::DoubleNestingImmutableStruct>( ::smoke::Structs::DoubleNestingImmutableStruct( _nestingStructField ) ); return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_DoubleNestingImmutableStruct_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_DoubleNestingImmutableStruct_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + _baseRef smoke_Structs_DoubleNestingImmutableStruct_nestingStructField_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::smoke::Structs::NestingImmutableStruct>::toBaseRef(struct_pointer->nesting_struct_field); } + + + _baseRef smoke_Structs_StructWithArrayOfImmutable_create_handle( _baseRef arrayField ) { + auto _arrayField = Conversion<::std::vector< ::smoke::Structs::AllTypesStruct >>::toCpp( arrayField ); ::smoke::Structs::StructWithArrayOfImmutable* _struct = new ( ::std::nothrow ) ::smoke::Structs::StructWithArrayOfImmutable( _arrayField ); return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_StructWithArrayOfImmutable_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::StructWithArrayOfImmutable>( handle ); } + _baseRef smoke_Structs_StructWithArrayOfImmutable_create_optional_handle(_baseRef arrayField) { + auto _arrayField = Conversion<::std::vector< ::smoke::Structs::AllTypesStruct >>::toCpp( arrayField ); auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::StructWithArrayOfImmutable>( ::smoke::Structs::StructWithArrayOfImmutable( _arrayField ) ); return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_StructWithArrayOfImmutable_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_StructWithArrayOfImmutable_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } + _baseRef smoke_Structs_StructWithArrayOfImmutable_arrayField_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); return Conversion<::std::vector< ::smoke::Structs::AllTypesStruct >>::toBaseRef(struct_pointer->array_field); } + + + _baseRef -smoke_Structs_ImmutableStructWithCppAccessors_create_handle( _baseRef stringField ) -{ - auto _stringField = Conversion<::std::string>::toCpp( stringField ); - ::smoke::Structs::ImmutableStructWithCppAccessors* _struct = new ( ::std::nothrow ) ::smoke::Structs::ImmutableStructWithCppAccessors( _stringField ); +smoke_Structs_ImmutableStructWithCppAccessors_create_handle( int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint ) +{ + + auto _trivialIntField = trivialIntField; + auto _trivialDoubleField = trivialDoubleField; + auto _nontrivialStringField = Conversion<::std::string>::toCpp( nontrivialStringField ); + auto _nontrivialPointField = Conversion<::smoke::Structs::Point>::toCpp( nontrivialPointField ); + auto _nontrivialOptionalPoint = Conversion>::toCpp( nontrivialOptionalPoint ); + ::smoke::Structs::ImmutableStructWithCppAccessors* _struct = new ( ::std::nothrow ) ::smoke::Structs::ImmutableStructWithCppAccessors( _trivialIntField, _trivialDoubleField, _nontrivialStringField, _nontrivialPointField, _nontrivialOptionalPoint ); return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_ImmutableStructWithCppAccessors_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::ImmutableStructWithCppAccessors>( handle ); } + _baseRef -smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(_baseRef stringField) -{ - auto _stringField = Conversion<::std::string>::toCpp( stringField ); - auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::ImmutableStructWithCppAccessors>( ::smoke::Structs::ImmutableStructWithCppAccessors( _stringField ) ); +smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint) +{ + + auto _trivialIntField = trivialIntField; + auto _trivialDoubleField = trivialDoubleField; + auto _nontrivialStringField = Conversion<::std::string>::toCpp( nontrivialStringField ); + auto _nontrivialPointField = Conversion<::smoke::Structs::Point>::toCpp( nontrivialPointField ); + auto _nontrivialOptionalPoint = Conversion>::toCpp( nontrivialOptionalPoint ); + auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::ImmutableStructWithCppAccessors>( ::smoke::Structs::ImmutableStructWithCppAccessors( _trivialIntField, _trivialDoubleField, _nontrivialStringField, _nontrivialPointField, _nontrivialOptionalPoint ) ); return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_ImmutableStructWithCppAccessors_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_ImmutableStructWithCppAccessors_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } -_baseRef smoke_Structs_ImmutableStructWithCppAccessors_stringField_get(_baseRef handle) { + +int32_t smoke_Structs_ImmutableStructWithCppAccessors_trivialIntField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return struct_pointer->get_trivial_int_field(); +} +double smoke_Structs_ImmutableStructWithCppAccessors_trivialDoubleField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return struct_pointer->get_trivial_double_field(); +} +_baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialStringField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return Conversion<::std::string>::toBaseRef(struct_pointer->get_nontrivial_string_field()); +} +_baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialPointField_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); - return Conversion<::std::string>::toBaseRef(struct_pointer->get_string_field()); + return Conversion<::smoke::Structs::Point>::toBaseRef(struct_pointer->get_nontrivial_point_field()); } +_baseRef smoke_Structs_ImmutableStructWithCppAccessors_nontrivialOptionalPoint_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return Conversion>::toBaseRef(struct_pointer->get_nontrivial_optional_point()); +} + + + _baseRef -smoke_Structs_MutableStructWithCppAccessors_create_handle( _baseRef stringField ) +smoke_Structs_MutableStructWithCppAccessors_create_handle( int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint ) { ::smoke::Structs::MutableStructWithCppAccessors* _struct = new ( ::std::nothrow ) ::smoke::Structs::MutableStructWithCppAccessors(); - _struct->set_string_field( Conversion<::std::string>::toCpp( stringField ) ); + _struct->set_trivial_int_field( trivialIntField ); + _struct->set_trivial_double_field( trivialDoubleField ); + _struct->set_nontrivial_string_field( Conversion<::std::string>::toCpp( nontrivialStringField ) ); + _struct->set_nontrivial_point_field( Conversion<::smoke::Structs::Point>::toCpp( nontrivialPointField ) ); + _struct->set_nontrivial_optional_point( Conversion>::toCpp( nontrivialOptionalPoint ) ); + return reinterpret_cast<_baseRef>( _struct ); } + void smoke_Structs_MutableStructWithCppAccessors_release_handle( _baseRef handle ) { delete get_pointer<::smoke::Structs::MutableStructWithCppAccessors>( handle ); } + _baseRef -smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(_baseRef stringField) +smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(int32_t trivialIntField, double trivialDoubleField, _baseRef nontrivialStringField, _baseRef nontrivialPointField, _baseRef nontrivialOptionalPoint) { auto _struct = new ( ::std::nothrow ) std::optional<::smoke::Structs::MutableStructWithCppAccessors>( ::smoke::Structs::MutableStructWithCppAccessors( ) ); - (*_struct)->set_string_field( Conversion<::std::string>::toCpp( stringField ) ); + (*_struct)->set_trivial_int_field( trivialIntField ); + (*_struct)->set_trivial_double_field( trivialDoubleField ); + (*_struct)->set_nontrivial_string_field( Conversion<::std::string>::toCpp( nontrivialStringField ) ); + (*_struct)->set_nontrivial_point_field( Conversion<::smoke::Structs::Point>::toCpp( nontrivialPointField ) ); + (*_struct)->set_nontrivial_optional_point( Conversion>::toCpp( nontrivialOptionalPoint ) ); + return reinterpret_cast<_baseRef>( _struct ); } + _baseRef smoke_Structs_MutableStructWithCppAccessors_unwrap_optional_handle( _baseRef handle ) { return reinterpret_cast<_baseRef>( &**reinterpret_cast*>( handle ) ); } + void smoke_Structs_MutableStructWithCppAccessors_release_optional_handle(_baseRef handle) { delete reinterpret_cast*>( handle ); } -_baseRef smoke_Structs_MutableStructWithCppAccessors_stringField_get(_baseRef handle) { + +int32_t smoke_Structs_MutableStructWithCppAccessors_trivialIntField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return struct_pointer->get_trivial_int_field(); +} +double smoke_Structs_MutableStructWithCppAccessors_trivialDoubleField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return struct_pointer->get_trivial_double_field(); +} +_baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialStringField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return Conversion<::std::string>::toBaseRef(struct_pointer->get_nontrivial_string_field()); +} +_baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialPointField_get(_baseRef handle) { + auto struct_pointer = get_pointer(handle); + return Conversion<::smoke::Structs::Point>::toBaseRef(struct_pointer->get_nontrivial_point_field()); +} +_baseRef smoke_Structs_MutableStructWithCppAccessors_nontrivialOptionalPoint_get(_baseRef handle) { auto struct_pointer = get_pointer(handle); - return Conversion<::std::string>::toBaseRef(struct_pointer->get_string_field()); + return Conversion>::toBaseRef(struct_pointer->get_nontrivial_optional_point()); } + + + + + diff --git a/gluecodium/src/test/resources/smoke/structs/output/cpp/include/smoke/Structs.h b/gluecodium/src/test/resources/smoke/structs/output/cpp/include/smoke/Structs.h index ff17a9a445..21b955bfb0 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/cpp/include/smoke/Structs.h +++ b/gluecodium/src/test/resources/smoke/structs/output/cpp/include/smoke/Structs.h @@ -11,6 +11,7 @@ #include "smoke/TypeCollection.h" #include #include +#include #include #include @@ -95,29 +96,78 @@ class _GLUECODIUM_CPP_EXPORT Structs { struct _GLUECODIUM_CPP_EXPORT ImmutableStructWithCppAccessors { private: - ::std::string string_field; + int32_t trivial_int_field; + double trivial_double_field; + ::std::string nontrivial_string_field; + ::smoke::Structs::Point nontrivial_point_field; + std::optional< ::smoke::Structs::Point > nontrivial_optional_point = std::optional< ::smoke::Structs::Point >(); public: - explicit ImmutableStructWithCppAccessors( ::std::string string_field ); + ImmutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field ); + ImmutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field, std::optional< ::smoke::Structs::Point > nontrivial_optional_point ); - ::std::string get_string_field( ) const { return string_field; } + int32_t get_trivial_int_field( ) const { return trivial_int_field; } + + double get_trivial_double_field( ) const { return trivial_double_field; } + + const ::std::string& get_nontrivial_string_field( ) const & { return nontrivial_string_field; } + ::std::string&& get_nontrivial_string_field( ) && { return std::move(nontrivial_string_field); } + const ::std::string&& get_nontrivial_string_field( ) const && { return std::move(nontrivial_string_field); } + + const ::smoke::Structs::Point& get_nontrivial_point_field( ) const & { return nontrivial_point_field; } + ::smoke::Structs::Point&& get_nontrivial_point_field( ) && { return std::move(nontrivial_point_field); } + const ::smoke::Structs::Point&& get_nontrivial_point_field( ) const && { return std::move(nontrivial_point_field); } + + const std::optional< ::smoke::Structs::Point >& get_nontrivial_optional_point( ) const & { return nontrivial_optional_point; } + std::optional< ::smoke::Structs::Point >&& get_nontrivial_optional_point( ) && { return std::move(nontrivial_optional_point); } + const std::optional< ::smoke::Structs::Point >&& get_nontrivial_optional_point( ) const && { return std::move(nontrivial_optional_point); } }; struct _GLUECODIUM_CPP_EXPORT MutableStructWithCppAccessors { private: - ::std::string string_field; + int32_t trivial_int_field; + double trivial_double_field; + ::std::string nontrivial_string_field; + ::smoke::Structs::Point nontrivial_point_field; + std::optional< ::smoke::Structs::Point > nontrivial_optional_point = std::optional< ::smoke::Structs::Point >(); public: MutableStructWithCppAccessors( ); - explicit MutableStructWithCppAccessors( ::std::string string_field ); + MutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field ); + MutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field, std::optional< ::smoke::Structs::Point > nontrivial_optional_point ); + + + int32_t get_trivial_int_field( ) const { return trivial_int_field; } + + void set_trivial_int_field( int32_t value_ ) { trivial_int_field = value_; } + + double get_trivial_double_field( ) const { return trivial_double_field; } + + void set_trivial_double_field( double value_ ) { trivial_double_field = value_; } + + const ::std::string& get_nontrivial_string_field( ) const & { return nontrivial_string_field; } + ::std::string&& get_nontrivial_string_field( ) && { return std::move(nontrivial_string_field); } + const ::std::string&& get_nontrivial_string_field( ) const && { return std::move(nontrivial_string_field); } + + void set_nontrivial_string_field( const ::std::string& value_ ) { nontrivial_string_field = value_; } + void set_nontrivial_string_field( ::std::string&& value_ ) { nontrivial_string_field = std::move(value_); } + + const ::smoke::Structs::Point& get_nontrivial_point_field( ) const & { return nontrivial_point_field; } + ::smoke::Structs::Point&& get_nontrivial_point_field( ) && { return std::move(nontrivial_point_field); } + const ::smoke::Structs::Point&& get_nontrivial_point_field( ) const && { return std::move(nontrivial_point_field); } + void set_nontrivial_point_field( const ::smoke::Structs::Point& value_ ) { nontrivial_point_field = value_; } + void set_nontrivial_point_field( ::smoke::Structs::Point&& value_ ) { nontrivial_point_field = std::move(value_); } - ::std::string get_string_field( ) const { return string_field; } + const std::optional< ::smoke::Structs::Point >& get_nontrivial_optional_point( ) const & { return nontrivial_optional_point; } + std::optional< ::smoke::Structs::Point >&& get_nontrivial_optional_point( ) && { return std::move(nontrivial_optional_point); } + const std::optional< ::smoke::Structs::Point >&& get_nontrivial_optional_point( ) const && { return std::move(nontrivial_optional_point); } - void set_string_field( ::std::string value_ ) { string_field = value_; } + void set_nontrivial_optional_point( const std::optional< ::smoke::Structs::Point >& value_ ) { nontrivial_optional_point = value_; } + void set_nontrivial_optional_point( std::optional< ::smoke::Structs::Point >&& value_ ) { nontrivial_optional_point = std::move(value_); } }; diff --git a/gluecodium/src/test/resources/smoke/structs/output/cpp/src/smoke/Structs.cpp b/gluecodium/src/test/resources/smoke/structs/output/cpp/src/smoke/Structs.cpp index 9db53501f3..4391a7b5b1 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/cpp/src/smoke/Structs.cpp +++ b/gluecodium/src/test/resources/smoke/structs/output/cpp/src/smoke/Structs.cpp @@ -1,60 +1,99 @@ // ------------------------------------------------------------------------------------------------- // + // // ------------------------------------------------------------------------------------------------- + #include "smoke/Structs.h" #include + namespace smoke { Structs::Structs() { } Structs::~Structs() { } + + + Structs::Point::Point( ) : x{ }, y{ } { } + Structs::Point::Point( double x, double y ) : x( std::move( x ) ), y( std::move( y ) ) { } + + Structs::Line::Line( ) : a{ }, b{ } { } + Structs::Line::Line( ::smoke::Structs::Point a, ::smoke::Structs::Point b ) : a( std::move( a ) ), b( std::move( b ) ) { } + + + Structs::AllTypesStruct::AllTypesStruct( int8_t int8_field, uint8_t uint8_field, int16_t int16_field, uint16_t uint16_field, int32_t int32_field, uint32_t uint32_field, int64_t int64_field, uint64_t uint64_field, float float_field, double double_field, ::std::string string_field, bool boolean_field, ::std::shared_ptr< ::std::vector< uint8_t > > bytes_field, ::smoke::Structs::Point point_field ) : int8_field( std::move( int8_field ) ), uint8_field( std::move( uint8_field ) ), int16_field( std::move( int16_field ) ), uint16_field( std::move( uint16_field ) ), int32_field( std::move( int32_field ) ), uint32_field( std::move( uint32_field ) ), int64_field( std::move( int64_field ) ), uint64_field( std::move( uint64_field ) ), float_field( std::move( float_field ) ), double_field( std::move( double_field ) ), string_field( std::move( string_field ) ), boolean_field( std::move( boolean_field ) ), bytes_field( std::move( bytes_field ) ), point_field( std::move( point_field ) ) { } + + + Structs::NestingImmutableStruct::NestingImmutableStruct( ::smoke::Structs::AllTypesStruct struct_field ) : struct_field( std::move( struct_field ) ) { } + + + Structs::DoubleNestingImmutableStruct::DoubleNestingImmutableStruct( ::smoke::Structs::NestingImmutableStruct nesting_struct_field ) : nesting_struct_field( std::move( nesting_struct_field ) ) { } + + Structs::StructWithArrayOfImmutable::StructWithArrayOfImmutable( ) : array_field{ } { } + Structs::StructWithArrayOfImmutable::StructWithArrayOfImmutable( ::smoke::Structs::ArrayOfImmutable array_field ) : array_field( std::move( array_field ) ) { } -Structs::ImmutableStructWithCppAccessors::ImmutableStructWithCppAccessors( ::std::string string_field ) - : string_field( std::move( string_field ) ) + + + +Structs::ImmutableStructWithCppAccessors::ImmutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field ) + : trivial_int_field( std::move( trivial_int_field ) ), trivial_double_field( std::move( trivial_double_field ) ), nontrivial_string_field( std::move( nontrivial_string_field ) ), nontrivial_point_field( std::move( nontrivial_point_field ) ) { } +Structs::ImmutableStructWithCppAccessors::ImmutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field, std::optional< ::smoke::Structs::Point > nontrivial_optional_point ) + : trivial_int_field( std::move( trivial_int_field ) ), trivial_double_field( std::move( trivial_double_field ) ), nontrivial_string_field( std::move( nontrivial_string_field ) ), nontrivial_point_field( std::move( nontrivial_point_field ) ), nontrivial_optional_point( std::move( nontrivial_optional_point ) ) +{ +} + + Structs::MutableStructWithCppAccessors::MutableStructWithCppAccessors( ) - : string_field{ } + : trivial_int_field{ }, trivial_double_field{ }, nontrivial_string_field{ }, nontrivial_point_field{ } +{ +} + +Structs::MutableStructWithCppAccessors::MutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field ) + : trivial_int_field( std::move( trivial_int_field ) ), trivial_double_field( std::move( trivial_double_field ) ), nontrivial_string_field( std::move( nontrivial_string_field ) ), nontrivial_point_field( std::move( nontrivial_point_field ) ) { } -Structs::MutableStructWithCppAccessors::MutableStructWithCppAccessors( ::std::string string_field ) - : string_field( std::move( string_field ) ) +Structs::MutableStructWithCppAccessors::MutableStructWithCppAccessors( int32_t trivial_int_field, double trivial_double_field, ::std::string nontrivial_string_field, ::smoke::Structs::Point nontrivial_point_field, std::optional< ::smoke::Structs::Point > nontrivial_optional_point ) + : trivial_int_field( std::move( trivial_int_field ) ), trivial_double_field( std::move( trivial_double_field ) ), nontrivial_string_field( std::move( nontrivial_string_field ) ), nontrivial_point_field( std::move( nontrivial_point_field ) ), nontrivial_optional_point( std::move( nontrivial_optional_point ) ) { } + + } + diff --git a/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.cpp b/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.cpp index fbcca0fc19..d4e1991271 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.cpp +++ b/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.cpp @@ -1,4 +1,6 @@ + #include "ffi_smoke_Structs.h" + #include "ConversionBase.h" #include "InstanceCache.h" #include "FinalizerData.h" @@ -8,14 +10,21 @@ #include "smoke/TypeCollection.h" #include #include +#include #include #include #include #include #include + + #ifdef __cplusplus extern "C" { #endif + + + + FfiOpaqueHandle library_smoke_Structs_swapPointCoordinates__Point(int32_t _isolate_id, FfiOpaqueHandle input) { gluecodium::ffi::IsolateContext _isolate_context(_isolate_id); @@ -25,6 +34,9 @@ library_smoke_Structs_swapPointCoordinates__Point(int32_t _isolate_id, FfiOpaque ) ); } + + + FfiOpaqueHandle library_smoke_Structs_returnAllTypesStruct__AllTypesStruct(int32_t _isolate_id, FfiOpaqueHandle input) { gluecodium::ffi::IsolateContext _isolate_context(_isolate_id); @@ -34,6 +46,9 @@ library_smoke_Structs_returnAllTypesStruct__AllTypesStruct(int32_t _isolate_id, ) ); } + + + FfiOpaqueHandle library_smoke_Structs_createPoint__Double_Double(int32_t _isolate_id, double x, double y) { gluecodium::ffi::IsolateContext _isolate_context(_isolate_id); @@ -44,6 +59,9 @@ library_smoke_Structs_createPoint__Double_Double(int32_t _isolate_id, double x, ) ); } + + + FfiOpaqueHandle library_smoke_Structs_modifyAllTypesStruct__AllTypesStruct(int32_t _isolate_id, FfiOpaqueHandle input) { gluecodium::ffi::IsolateContext _isolate_context(_isolate_id); @@ -53,6 +71,37 @@ library_smoke_Structs_modifyAllTypesStruct__AllTypesStruct(int32_t _isolate_id, ) ); } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // "Private" finalizer, not exposed to be callable from Dart. void library_smoke_Structs_finalizer(FfiOpaqueHandle handle, int32_t isolate_id) { @@ -60,11 +109,13 @@ library_smoke_Structs_finalizer(FfiOpaqueHandle handle, int32_t isolate_id) { library_uncache_dart_handle_by_raw_pointer(ptr_ptr->get(), isolate_id); library_smoke_Structs_release_handle(handle); } + void library_smoke_Structs_register_finalizer(FfiOpaqueHandle ffi_handle, int32_t isolate_id, Dart_Handle dart_handle) { FinalizerData* data = new (std::nothrow) FinalizerData{ffi_handle, isolate_id, &library_smoke_Structs_finalizer}; Dart_NewFinalizableHandle_DL(dart_handle, data, sizeof data, &library_execute_finalizer); } + FfiOpaqueHandle library_smoke_Structs_copy_handle(FfiOpaqueHandle handle) { return reinterpret_cast( @@ -73,33 +124,53 @@ library_smoke_Structs_copy_handle(FfiOpaqueHandle handle) { ) ); } + void library_smoke_Structs_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + + + + FfiOpaqueHandle library_smoke_Structs_Point_create_handle(double x, double y) { auto _result = new (std::nothrow) smoke::Structs::Point(); + + _result->x = gluecodium::ffi::Conversion::toCpp(x); + + + _result->y = gluecodium::ffi::Conversion::toCpp(y); + return reinterpret_cast(_result); } + + void library_smoke_Structs_Point_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + double library_smoke_Structs_Point_get_field_x(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->x ); } + + double library_smoke_Structs_Point_get_field_y(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->y ); } + + + FfiOpaqueHandle library_smoke_Structs_Point_create_handle_nullable(FfiOpaqueHandle value) { @@ -109,11 +180,13 @@ library_smoke_Structs_Point_create_handle_nullable(FfiOpaqueHandle value) ) ); } + void library_smoke_Structs_Point_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_Point_get_value_nullable(FfiOpaqueHandle handle) { @@ -121,29 +194,46 @@ library_smoke_Structs_Point_get_value_nullable(FfiOpaqueHandle handle) **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle library_smoke_Structs_Line_create_handle(FfiOpaqueHandle a, FfiOpaqueHandle b) { auto _result = new (std::nothrow) smoke::Structs::Line(); + + _result->a = gluecodium::ffi::Conversion::toCpp(a); + + + _result->b = gluecodium::ffi::Conversion::toCpp(b); + return reinterpret_cast(_result); } + + void library_smoke_Structs_Line_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + FfiOpaqueHandle library_smoke_Structs_Line_get_field_a(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->a ); } + + FfiOpaqueHandle library_smoke_Structs_Line_get_field_b(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->b ); } + + + FfiOpaqueHandle library_smoke_Structs_Line_create_handle_nullable(FfiOpaqueHandle value) { @@ -153,11 +243,13 @@ library_smoke_Structs_Line_create_handle_nullable(FfiOpaqueHandle value) ) ); } + void library_smoke_Structs_Line_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_Line_get_value_nullable(FfiOpaqueHandle handle) { @@ -165,99 +257,134 @@ library_smoke_Structs_Line_get_value_nullable(FfiOpaqueHandle handle) **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_create_handle(int8_t int8Field, uint8_t uint8Field, int16_t int16Field, uint16_t uint16Field, int32_t int32Field, uint32_t uint32Field, int64_t int64Field, uint64_t uint64Field, float floatField, double doubleField, FfiOpaqueHandle stringField, bool booleanField, FfiOpaqueHandle bytesField, FfiOpaqueHandle pointField) { auto _result = new (std::nothrow) smoke::Structs::AllTypesStruct(gluecodium::ffi::Conversion::toCpp(int8Field), gluecodium::ffi::Conversion::toCpp(uint8Field), gluecodium::ffi::Conversion::toCpp(int16Field), gluecodium::ffi::Conversion::toCpp(uint16Field), gluecodium::ffi::Conversion::toCpp(int32Field), gluecodium::ffi::Conversion::toCpp(uint32Field), gluecodium::ffi::Conversion::toCpp(int64Field), gluecodium::ffi::Conversion::toCpp(uint64Field), gluecodium::ffi::Conversion::toCpp(floatField), gluecodium::ffi::Conversion::toCpp(doubleField), gluecodium::ffi::Conversion::toCpp(stringField), gluecodium::ffi::Conversion::toCpp(booleanField), gluecodium::ffi::Conversion>>::toCpp(bytesField), gluecodium::ffi::Conversion::toCpp(pointField)); return reinterpret_cast(_result); } + + void library_smoke_Structs_AllTypesStruct_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + int8_t library_smoke_Structs_AllTypesStruct_get_field_int8Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->int8_field ); } + + uint8_t library_smoke_Structs_AllTypesStruct_get_field_uint8Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->uint8_field ); } + + int16_t library_smoke_Structs_AllTypesStruct_get_field_int16Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->int16_field ); } + + uint16_t library_smoke_Structs_AllTypesStruct_get_field_uint16Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->uint16_field ); } + + int32_t library_smoke_Structs_AllTypesStruct_get_field_int32Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->int32_field ); } + + uint32_t library_smoke_Structs_AllTypesStruct_get_field_uint32Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->uint32_field ); } + + int64_t library_smoke_Structs_AllTypesStruct_get_field_int64Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->int64_field ); } + + uint64_t library_smoke_Structs_AllTypesStruct_get_field_uint64Field(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->uint64_field ); } + + float library_smoke_Structs_AllTypesStruct_get_field_floatField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->float_field ); } + + double library_smoke_Structs_AllTypesStruct_get_field_doubleField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->double_field ); } + + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_get_field_stringField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->string_field ); } + + bool library_smoke_Structs_AllTypesStruct_get_field_booleanField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->boolean_field ); } + + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_get_field_bytesField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion>>::toFfi( reinterpret_cast(handle)->bytes_field ); } + + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_get_field_pointField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->point_field ); } + + + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_create_handle_nullable(FfiOpaqueHandle value) { @@ -267,11 +394,13 @@ library_smoke_Structs_AllTypesStruct_create_handle_nullable(FfiOpaqueHandle valu ) ); } + void library_smoke_Structs_AllTypesStruct_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_AllTypesStruct_get_value_nullable(FfiOpaqueHandle handle) { @@ -279,21 +408,30 @@ library_smoke_Structs_AllTypesStruct_get_value_nullable(FfiOpaqueHandle handle) **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle library_smoke_Structs_NestingImmutableStruct_create_handle(FfiOpaqueHandle structField) { auto _result = new (std::nothrow) smoke::Structs::NestingImmutableStruct(gluecodium::ffi::Conversion::toCpp(structField)); return reinterpret_cast(_result); } + + void library_smoke_Structs_NestingImmutableStruct_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + FfiOpaqueHandle library_smoke_Structs_NestingImmutableStruct_get_field_structField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->struct_field ); } + + + FfiOpaqueHandle library_smoke_Structs_NestingImmutableStruct_create_handle_nullable(FfiOpaqueHandle value) { @@ -303,11 +441,13 @@ library_smoke_Structs_NestingImmutableStruct_create_handle_nullable(FfiOpaqueHan ) ); } + void library_smoke_Structs_NestingImmutableStruct_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_NestingImmutableStruct_get_value_nullable(FfiOpaqueHandle handle) { @@ -315,21 +455,30 @@ library_smoke_Structs_NestingImmutableStruct_get_value_nullable(FfiOpaqueHandle **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle library_smoke_Structs_DoubleNestingImmutableStruct_create_handle(FfiOpaqueHandle nestingStructField) { auto _result = new (std::nothrow) smoke::Structs::DoubleNestingImmutableStruct(gluecodium::ffi::Conversion::toCpp(nestingStructField)); return reinterpret_cast(_result); } + + void library_smoke_Structs_DoubleNestingImmutableStruct_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + FfiOpaqueHandle library_smoke_Structs_DoubleNestingImmutableStruct_get_field_nestingStructField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( reinterpret_cast(handle)->nesting_struct_field ); } + + + FfiOpaqueHandle library_smoke_Structs_DoubleNestingImmutableStruct_create_handle_nullable(FfiOpaqueHandle value) { @@ -339,11 +488,13 @@ library_smoke_Structs_DoubleNestingImmutableStruct_create_handle_nullable(FfiOpa ) ); } + void library_smoke_Structs_DoubleNestingImmutableStruct_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_DoubleNestingImmutableStruct_get_value_nullable(FfiOpaqueHandle handle) { @@ -351,21 +502,30 @@ library_smoke_Structs_DoubleNestingImmutableStruct_get_value_nullable(FfiOpaqueH **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_create_handle(FfiOpaqueHandle arrayField) { auto _result = new (std::nothrow) smoke::Structs::StructWithArrayOfImmutable(gluecodium::ffi::Conversion>::toCpp(arrayField)); return reinterpret_cast(_result); } + + void library_smoke_Structs_StructWithArrayOfImmutable_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_get_field_arrayField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion>::toFfi( reinterpret_cast(handle)->array_field ); } + + + FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_create_handle_nullable(FfiOpaqueHandle value) { @@ -375,11 +535,13 @@ library_smoke_Structs_StructWithArrayOfImmutable_create_handle_nullable(FfiOpaqu ) ); } + void library_smoke_Structs_StructWithArrayOfImmutable_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_get_value_nullable(FfiOpaqueHandle handle) { @@ -387,21 +549,62 @@ library_smoke_Structs_StructWithArrayOfImmutable_get_value_nullable(FfiOpaqueHan **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle -library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle(FfiOpaqueHandle stringField) { - auto _result = new (std::nothrow) smoke::Structs::ImmutableStructWithCppAccessors(gluecodium::ffi::Conversion::toCpp(stringField)); +library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, FfiOpaqueHandle nontrivialStringField, FfiOpaqueHandle nontrivialPointField, FfiOpaqueHandle nontrivialOptionalPoint) { + auto _result = new (std::nothrow) smoke::Structs::ImmutableStructWithCppAccessors(gluecodium::ffi::Conversion::toCpp(trivialIntField), gluecodium::ffi::Conversion::toCpp(trivialDoubleField), gluecodium::ffi::Conversion::toCpp(nontrivialStringField), gluecodium::ffi::Conversion::toCpp(nontrivialPointField), gluecodium::ffi::Conversion>::toCpp(nontrivialOptionalPoint)); return reinterpret_cast(_result); } + + void library_smoke_Structs_ImmutableStructWithCppAccessors_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + +int32_t +library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialIntField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_trivial_int_field() + ); +} + + +double +library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialDoubleField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_trivial_double_field() + ); +} + + FfiOpaqueHandle -library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_stringField(FfiOpaqueHandle handle) { +library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialStringField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( - reinterpret_cast(handle)->get_string_field() + reinterpret_cast(handle)->get_nontrivial_string_field() + ); +} + + +FfiOpaqueHandle +library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialPointField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_nontrivial_point_field() + ); +} + + +FfiOpaqueHandle +library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialOptionalPoint(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion>::toFfi( + reinterpret_cast(handle)->get_nontrivial_optional_point() ); } + + + FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle_nullable(FfiOpaqueHandle value) { @@ -411,11 +614,13 @@ library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle_nullable(Ffi ) ); } + void library_smoke_Structs_ImmutableStructWithCppAccessors_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_value_nullable(FfiOpaqueHandle handle) { @@ -423,22 +628,82 @@ library_smoke_Structs_ImmutableStructWithCppAccessors_get_value_nullable(FfiOpaq **reinterpret_cast*>(handle) ); } + + FfiOpaqueHandle -library_smoke_Structs_MutableStructWithCppAccessors_create_handle(FfiOpaqueHandle stringField) { +library_smoke_Structs_MutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, FfiOpaqueHandle nontrivialStringField, FfiOpaqueHandle nontrivialPointField, FfiOpaqueHandle nontrivialOptionalPoint) { auto _result = new (std::nothrow) smoke::Structs::MutableStructWithCppAccessors(); - _result->set_string_field(gluecodium::ffi::Conversion::toCpp(stringField)); + + + _result->set_trivial_int_field(gluecodium::ffi::Conversion::toCpp(trivialIntField)); + + + + _result->set_trivial_double_field(gluecodium::ffi::Conversion::toCpp(trivialDoubleField)); + + + + _result->set_nontrivial_string_field(gluecodium::ffi::Conversion::toCpp(nontrivialStringField)); + + + + _result->set_nontrivial_point_field(gluecodium::ffi::Conversion::toCpp(nontrivialPointField)); + + + + _result->set_nontrivial_optional_point(gluecodium::ffi::Conversion>::toCpp(nontrivialOptionalPoint)); + return reinterpret_cast(_result); } + + void library_smoke_Structs_MutableStructWithCppAccessors_release_handle(FfiOpaqueHandle handle) { delete reinterpret_cast(handle); } + + +int32_t +library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialIntField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_trivial_int_field() + ); +} + + +double +library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialDoubleField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_trivial_double_field() + ); +} + + FfiOpaqueHandle -library_smoke_Structs_MutableStructWithCppAccessors_get_field_stringField(FfiOpaqueHandle handle) { +library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialStringField(FfiOpaqueHandle handle) { return gluecodium::ffi::Conversion::toFfi( - reinterpret_cast(handle)->get_string_field() + reinterpret_cast(handle)->get_nontrivial_string_field() + ); +} + + +FfiOpaqueHandle +library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialPointField(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion::toFfi( + reinterpret_cast(handle)->get_nontrivial_point_field() + ); +} + + +FfiOpaqueHandle +library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialOptionalPoint(FfiOpaqueHandle handle) { + return gluecodium::ffi::Conversion>::toFfi( + reinterpret_cast(handle)->get_nontrivial_optional_point() ); } + + + FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_create_handle_nullable(FfiOpaqueHandle value) { @@ -448,11 +713,13 @@ library_smoke_Structs_MutableStructWithCppAccessors_create_handle_nullable(FfiOp ) ); } + void library_smoke_Structs_MutableStructWithCppAccessors_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_value_nullable(FfiOpaqueHandle handle) { @@ -460,6 +727,9 @@ library_smoke_Structs_MutableStructWithCppAccessors_get_value_nullable(FfiOpaque **reinterpret_cast*>(handle) ); } + + + FfiOpaqueHandle library_smoke_Structs_FooBar_create_handle_nullable(uint32_t value) { @@ -469,11 +739,13 @@ library_smoke_Structs_FooBar_create_handle_nullable(uint32_t value) ) ); } + void library_smoke_Structs_FooBar_release_handle_nullable(FfiOpaqueHandle handle) { delete reinterpret_cast*>(handle); } + uint32_t library_smoke_Structs_FooBar_get_value_nullable(FfiOpaqueHandle handle) { @@ -481,6 +753,8 @@ library_smoke_Structs_FooBar_get_value_nullable(FfiOpaqueHandle handle) **reinterpret_cast*>(handle) ); } + + #ifdef __cplusplus } #endif diff --git a/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.h b/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.h index 91fa231a27..4524e80410 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.h +++ b/gluecodium/src/test/resources/smoke/structs/output/dart/ffi/ffi_smoke_Structs.h @@ -1,18 +1,64 @@ + #pragma once + #include "Export.h" #include "OpaqueHandle.h" #include "dart_api_dl.h" #include + #ifdef __cplusplus extern "C" { #endif + + + + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_swapPointCoordinates__Point(int32_t _isolate_id, FfiOpaqueHandle input); + + + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_returnAllTypesStruct__AllTypesStruct(int32_t _isolate_id, FfiOpaqueHandle input); + + + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_createPoint__Double_Double(int32_t _isolate_id, double x, double y); + + + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_modifyAllTypesStruct__AllTypesStruct(int32_t _isolate_id, FfiOpaqueHandle input); + + + + + + + + + + + + + + + + + + + + + + + + + + + + _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_register_finalizer(FfiOpaqueHandle ffi_handle, int32_t isolate_id, Dart_Handle dart_handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_copy_handle(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_release_handle(FfiOpaqueHandle handle); + + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_Point_create_handle(double x, double y); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_Point_release_handle(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT double library_smoke_Structs_Point_get_field_x(FfiOpaqueHandle handle); @@ -64,21 +110,31 @@ _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfIm _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_create_handle_nullable(FfiOpaqueHandle value); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_StructWithArrayOfImmutable_release_handle_nullable(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_StructWithArrayOfImmutable_get_value_nullable(FfiOpaqueHandle handle); -_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle(FfiOpaqueHandle stringField); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, FfiOpaqueHandle nontrivialStringField, FfiOpaqueHandle nontrivialPointField, FfiOpaqueHandle nontrivialOptionalPoint); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_ImmutableStructWithCppAccessors_release_handle(FfiOpaqueHandle handle); -_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_stringField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT int32_t library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialIntField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT double library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialDoubleField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialStringField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialPointField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialOptionalPoint(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle_nullable(FfiOpaqueHandle value); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_ImmutableStructWithCppAccessors_release_handle_nullable(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_ImmutableStructWithCppAccessors_get_value_nullable(FfiOpaqueHandle handle); -_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_create_handle(FfiOpaqueHandle stringField); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_create_handle(int32_t trivialIntField, double trivialDoubleField, FfiOpaqueHandle nontrivialStringField, FfiOpaqueHandle nontrivialPointField, FfiOpaqueHandle nontrivialOptionalPoint); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_MutableStructWithCppAccessors_release_handle(FfiOpaqueHandle handle); -_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_field_stringField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT int32_t library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialIntField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT double library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialDoubleField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialStringField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialPointField(FfiOpaqueHandle handle); +_GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialOptionalPoint(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_create_handle_nullable(FfiOpaqueHandle value); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_MutableStructWithCppAccessors_release_handle_nullable(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_MutableStructWithCppAccessors_get_value_nullable(FfiOpaqueHandle handle); + _GLUECODIUM_FFI_EXPORT FfiOpaqueHandle library_smoke_Structs_FooBar_create_handle_nullable(uint32_t value); _GLUECODIUM_FFI_EXPORT void library_smoke_Structs_FooBar_release_handle_nullable(FfiOpaqueHandle handle); _GLUECODIUM_FFI_EXPORT uint32_t library_smoke_Structs_FooBar_get_value_nullable(FfiOpaqueHandle handle); + #ifdef __cplusplus } #endif diff --git a/gluecodium/src/test/resources/smoke/structs/output/dart/lib/src/smoke/structs.dart b/gluecodium/src/test/resources/smoke/structs/output/dart/lib/src/smoke/structs.dart index ee251fd1d6..3deb062b27 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/dart/lib/src/smoke/structs.dart +++ b/gluecodium/src/test/resources/smoke/structs/output/dart/lib/src/smoke/structs.dart @@ -1,3 +1,5 @@ + + import 'dart:ffi'; import 'dart:typed_data'; import 'package:library/src/_library_context.dart' as __lib; @@ -7,20 +9,30 @@ import 'package:library/src/builtin_types__conversion.dart'; import 'package:library/src/generic_types__conversion.dart'; import 'package:library/src/smoke/type_collection.dart'; import 'package:meta/meta.dart'; + abstract class Structs { + + static Structs_Point swapPointCoordinates(Structs_Point input) => $prototype.swapPointCoordinates(input); + static Structs_AllTypesStruct returnAllTypesStruct(Structs_AllTypesStruct input) => $prototype.returnAllTypesStruct(input); + static TypeCollection_Point createPoint(double x, double y) => $prototype.createPoint(x, y); + static TypeCollection_AllTypesStruct modifyAllTypesStruct(TypeCollection_AllTypesStruct input) => $prototype.modifyAllTypesStruct(input); + /// @nodoc @visibleForTesting static dynamic $prototype = Structs$Impl(Pointer.fromAddress(0)); } + enum Structs_FooBar { foo, bar } + // Structs_FooBar "private" section, not exported. + int smokeStructsFoobarToFfi(Structs_FooBar value) { switch (value) { case Structs_FooBar.foo: @@ -31,6 +43,7 @@ int smokeStructsFoobarToFfi(Structs_FooBar value) { throw StateError("Invalid enum value $value for Structs_FooBar enum."); } } + Structs_FooBar smokeStructsFoobarFromFfi(int handle) { switch (handle) { case 0: @@ -41,7 +54,9 @@ Structs_FooBar smokeStructsFoobarFromFfi(int handle) { throw StateError("Invalid numeric value $handle for Structs_FooBar enum."); } } + void smokeStructsFoobarReleaseFfiHandle(int handle) {} + final _smokeStructsFoobarCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Uint32), Pointer Function(int) @@ -54,6 +69,7 @@ final _smokeStructsFoobarGetValueNullable = __lib.catchArgumentError(() => __lib Uint32 Function(Pointer), int Function(Pointer) >('library_smoke_Structs_FooBar_get_value_nullable')); + Pointer smokeStructsFoobarToFfiNullable(Structs_FooBar? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsFoobarToFfi(value); @@ -61,6 +77,7 @@ Pointer smokeStructsFoobarToFfiNullable(Structs_FooBar? value) { smokeStructsFoobarReleaseFfiHandle(_handle); return result; } + Structs_FooBar? smokeStructsFoobarFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsFoobarGetValueNullable(handle); @@ -68,15 +85,23 @@ Structs_FooBar? smokeStructsFoobarFromFfiNullable(Pointer handle) { smokeStructsFoobarReleaseFfiHandle(_handle); return result; } + void smokeStructsFoobarReleaseFfiHandleNullable(Pointer handle) => _smokeStructsFoobarReleaseHandleNullable(handle); + // End of Structs_FooBar "private" section. + class Structs_Point { double x; + double y; + Structs_Point(this.x, this.y); } + + // Structs_Point "private" section, not exported. + final _smokeStructsPointCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Double, Double), Pointer Function(double, double) @@ -93,25 +118,36 @@ final _smokeStructsPointGetFieldy = __lib.catchArgumentError(() => __lib.nativeL Double Function(Pointer), double Function(Pointer) >('library_smoke_Structs_Point_get_field_y')); + + + Pointer smokeStructsPointToFfi(Structs_Point value) { final _xHandle = (value.x); final _yHandle = (value.y); final _result = _smokeStructsPointCreateHandle(_xHandle, _yHandle); + + return _result; } + Structs_Point smokeStructsPointFromFfi(Pointer handle) { final _xHandle = _smokeStructsPointGetFieldx(handle); final _yHandle = _smokeStructsPointGetFieldy(handle); try { return Structs_Point( - (_xHandle), + (_xHandle), (_yHandle) ); } finally { + + } } + void smokeStructsPointReleaseFfiHandle(Pointer handle) => _smokeStructsPointReleaseHandle(handle); + // Nullable Structs_Point + final _smokeStructsPointCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -124,6 +160,7 @@ final _smokeStructsPointGetValueNullable = __lib.catchArgumentError(() => __lib. Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_Point_get_value_nullable')); + Pointer smokeStructsPointToFfiNullable(Structs_Point? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsPointToFfi(value); @@ -131,6 +168,7 @@ Pointer smokeStructsPointToFfiNullable(Structs_Point? value) { smokeStructsPointReleaseFfiHandle(_handle); return result; } + Structs_Point? smokeStructsPointFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsPointGetValueNullable(handle); @@ -138,15 +176,23 @@ Structs_Point? smokeStructsPointFromFfiNullable(Pointer handle) { smokeStructsPointReleaseFfiHandle(_handle); return result; } + void smokeStructsPointReleaseFfiHandleNullable(Pointer handle) => _smokeStructsPointReleaseHandleNullable(handle); + // End of Structs_Point "private" section. + class Structs_Line { Structs_Point a; + Structs_Point b; + Structs_Line(this.a, this.b); } + + // Structs_Line "private" section, not exported. + final _smokeStructsLineCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer, Pointer), Pointer Function(Pointer, Pointer) @@ -163,6 +209,9 @@ final _smokeStructsLineGetFieldb = __lib.catchArgumentError(() => __lib.nativeLi Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_Line_get_field_b')); + + + Pointer smokeStructsLineToFfi(Structs_Line value) { final _aHandle = smokeStructsPointToFfi(value.a); final _bHandle = smokeStructsPointToFfi(value.b); @@ -171,12 +220,13 @@ Pointer smokeStructsLineToFfi(Structs_Line value) { smokeStructsPointReleaseFfiHandle(_bHandle); return _result; } + Structs_Line smokeStructsLineFromFfi(Pointer handle) { final _aHandle = _smokeStructsLineGetFielda(handle); final _bHandle = _smokeStructsLineGetFieldb(handle); try { return Structs_Line( - smokeStructsPointFromFfi(_aHandle), + smokeStructsPointFromFfi(_aHandle), smokeStructsPointFromFfi(_bHandle) ); } finally { @@ -184,8 +234,11 @@ Structs_Line smokeStructsLineFromFfi(Pointer handle) { smokeStructsPointReleaseFfiHandle(_bHandle); } } + void smokeStructsLineReleaseFfiHandle(Pointer handle) => _smokeStructsLineReleaseHandle(handle); + // Nullable Structs_Line + final _smokeStructsLineCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -198,6 +251,7 @@ final _smokeStructsLineGetValueNullable = __lib.catchArgumentError(() => __lib.n Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_Line_get_value_nullable')); + Pointer smokeStructsLineToFfiNullable(Structs_Line? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsLineToFfi(value); @@ -205,6 +259,7 @@ Pointer smokeStructsLineToFfiNullable(Structs_Line? value) { smokeStructsLineReleaseFfiHandle(_handle); return result; } + Structs_Line? smokeStructsLineFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsLineGetValueNullable(handle); @@ -212,28 +267,47 @@ Structs_Line? smokeStructsLineFromFfiNullable(Pointer handle) { smokeStructsLineReleaseFfiHandle(_handle); return result; } + void smokeStructsLineReleaseFfiHandleNullable(Pointer handle) => _smokeStructsLineReleaseHandleNullable(handle); + // End of Structs_Line "private" section. @immutable class Structs_AllTypesStruct { final int int8Field; + final int uint8Field; + final int int16Field; + final int uint16Field; + final int int32Field; + final int uint32Field; + final int int64Field; + final int uint64Field; + final double floatField; + final double doubleField; + final String stringField; + final bool booleanField; + final Uint8List bytesField; + final Structs_Point pointField; + const Structs_AllTypesStruct(this.int8Field, this.uint8Field, this.int16Field, this.uint16Field, this.int32Field, this.uint32Field, this.int64Field, this.uint64Field, this.floatField, this.doubleField, this.stringField, this.booleanField, this.bytesField, this.pointField); } + + // Structs_AllTypesStruct "private" section, not exported. + final _smokeStructsAlltypesstructCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Int8, Uint8, Int16, Uint16, Int32, Uint32, Int64, Uint64, Float, Double, Pointer, Uint8, Pointer, Pointer), Pointer Function(int, int, int, int, int, int, int, int, double, double, Pointer, int, Pointer, Pointer) @@ -298,6 +372,9 @@ final _smokeStructsAlltypesstructGetFieldpointField = __lib.catchArgumentError(( Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_AllTypesStruct_get_field_pointField')); + + + Pointer smokeStructsAlltypesstructToFfi(Structs_AllTypesStruct value) { final _int8FieldHandle = (value.int8Field); final _uint8FieldHandle = (value.uint8Field); @@ -314,12 +391,23 @@ Pointer smokeStructsAlltypesstructToFfi(Structs_AllTypesStruct value) { final _bytesFieldHandle = blobToFfi(value.bytesField); final _pointFieldHandle = smokeStructsPointToFfi(value.pointField); final _result = _smokeStructsAlltypesstructCreateHandle(_int8FieldHandle, _uint8FieldHandle, _int16FieldHandle, _uint16FieldHandle, _int32FieldHandle, _uint32FieldHandle, _int64FieldHandle, _uint64FieldHandle, _floatFieldHandle, _doubleFieldHandle, _stringFieldHandle, _booleanFieldHandle, _bytesFieldHandle, _pointFieldHandle); + + + + + + + + + + stringReleaseFfiHandle(_stringFieldHandle); booleanReleaseFfiHandle(_booleanFieldHandle); blobReleaseFfiHandle(_bytesFieldHandle); smokeStructsPointReleaseFfiHandle(_pointFieldHandle); return _result; } + Structs_AllTypesStruct smokeStructsAlltypesstructFromFfi(Pointer handle) { final _int8FieldHandle = _smokeStructsAlltypesstructGetFieldint8Field(handle); final _uint8FieldHandle = _smokeStructsAlltypesstructGetFielduint8Field(handle); @@ -337,30 +425,43 @@ Structs_AllTypesStruct smokeStructsAlltypesstructFromFfi(Pointer handle) { final _pointFieldHandle = _smokeStructsAlltypesstructGetFieldpointField(handle); try { return Structs_AllTypesStruct( - (_int8FieldHandle), - (_uint8FieldHandle), - (_int16FieldHandle), - (_uint16FieldHandle), - (_int32FieldHandle), - (_uint32FieldHandle), - (_int64FieldHandle), - (_uint64FieldHandle), - (_floatFieldHandle), - (_doubleFieldHandle), - stringFromFfi(_stringFieldHandle), - booleanFromFfi(_booleanFieldHandle), - blobFromFfi(_bytesFieldHandle), + (_int8FieldHandle), + (_uint8FieldHandle), + (_int16FieldHandle), + (_uint16FieldHandle), + (_int32FieldHandle), + (_uint32FieldHandle), + (_int64FieldHandle), + (_uint64FieldHandle), + (_floatFieldHandle), + (_doubleFieldHandle), + stringFromFfi(_stringFieldHandle), + booleanFromFfi(_booleanFieldHandle), + blobFromFfi(_bytesFieldHandle), smokeStructsPointFromFfi(_pointFieldHandle) ); } finally { + + + + + + + + + + stringReleaseFfiHandle(_stringFieldHandle); booleanReleaseFfiHandle(_booleanFieldHandle); blobReleaseFfiHandle(_bytesFieldHandle); smokeStructsPointReleaseFfiHandle(_pointFieldHandle); } } + void smokeStructsAlltypesstructReleaseFfiHandle(Pointer handle) => _smokeStructsAlltypesstructReleaseHandle(handle); + // Nullable Structs_AllTypesStruct + final _smokeStructsAlltypesstructCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -373,6 +474,7 @@ final _smokeStructsAlltypesstructGetValueNullable = __lib.catchArgumentError(() Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_AllTypesStruct_get_value_nullable')); + Pointer smokeStructsAlltypesstructToFfiNullable(Structs_AllTypesStruct? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsAlltypesstructToFfi(value); @@ -380,6 +482,7 @@ Pointer smokeStructsAlltypesstructToFfiNullable(Structs_AllTypesStruct? va smokeStructsAlltypesstructReleaseFfiHandle(_handle); return result; } + Structs_AllTypesStruct? smokeStructsAlltypesstructFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsAlltypesstructGetValueNullable(handle); @@ -387,14 +490,21 @@ Structs_AllTypesStruct? smokeStructsAlltypesstructFromFfiNullable(Pointer smokeStructsAlltypesstructReleaseFfiHandle(_handle); return result; } + void smokeStructsAlltypesstructReleaseFfiHandleNullable(Pointer handle) => _smokeStructsAlltypesstructReleaseHandleNullable(handle); + // End of Structs_AllTypesStruct "private" section. + class Structs_NestingImmutableStruct { Structs_AllTypesStruct structField; + Structs_NestingImmutableStruct(this.structField); } + + // Structs_NestingImmutableStruct "private" section, not exported. + final _smokeStructsNestingimmutablestructCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -407,12 +517,16 @@ final _smokeStructsNestingimmutablestructGetFieldstructField = __lib.catchArgume Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_NestingImmutableStruct_get_field_structField')); + + + Pointer smokeStructsNestingimmutablestructToFfi(Structs_NestingImmutableStruct value) { final _structFieldHandle = smokeStructsAlltypesstructToFfi(value.structField); final _result = _smokeStructsNestingimmutablestructCreateHandle(_structFieldHandle); smokeStructsAlltypesstructReleaseFfiHandle(_structFieldHandle); return _result; } + Structs_NestingImmutableStruct smokeStructsNestingimmutablestructFromFfi(Pointer handle) { final _structFieldHandle = _smokeStructsNestingimmutablestructGetFieldstructField(handle); try { @@ -423,8 +537,11 @@ Structs_NestingImmutableStruct smokeStructsNestingimmutablestructFromFfi(Pointer smokeStructsAlltypesstructReleaseFfiHandle(_structFieldHandle); } } + void smokeStructsNestingimmutablestructReleaseFfiHandle(Pointer handle) => _smokeStructsNestingimmutablestructReleaseHandle(handle); + // Nullable Structs_NestingImmutableStruct + final _smokeStructsNestingimmutablestructCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -437,6 +554,7 @@ final _smokeStructsNestingimmutablestructGetValueNullable = __lib.catchArgumentE Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_NestingImmutableStruct_get_value_nullable')); + Pointer smokeStructsNestingimmutablestructToFfiNullable(Structs_NestingImmutableStruct? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsNestingimmutablestructToFfi(value); @@ -444,6 +562,7 @@ Pointer smokeStructsNestingimmutablestructToFfiNullable(Structs_NestingImm smokeStructsNestingimmutablestructReleaseFfiHandle(_handle); return result; } + Structs_NestingImmutableStruct? smokeStructsNestingimmutablestructFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsNestingimmutablestructGetValueNullable(handle); @@ -451,14 +570,21 @@ Structs_NestingImmutableStruct? smokeStructsNestingimmutablestructFromFfiNullabl smokeStructsNestingimmutablestructReleaseFfiHandle(_handle); return result; } + void smokeStructsNestingimmutablestructReleaseFfiHandleNullable(Pointer handle) => _smokeStructsNestingimmutablestructReleaseHandleNullable(handle); + // End of Structs_NestingImmutableStruct "private" section. + class Structs_DoubleNestingImmutableStruct { Structs_NestingImmutableStruct nestingStructField; + Structs_DoubleNestingImmutableStruct(this.nestingStructField); } + + // Structs_DoubleNestingImmutableStruct "private" section, not exported. + final _smokeStructsDoublenestingimmutablestructCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -471,12 +597,16 @@ final _smokeStructsDoublenestingimmutablestructGetFieldnestingStructField = __li Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_DoubleNestingImmutableStruct_get_field_nestingStructField')); + + + Pointer smokeStructsDoublenestingimmutablestructToFfi(Structs_DoubleNestingImmutableStruct value) { final _nestingStructFieldHandle = smokeStructsNestingimmutablestructToFfi(value.nestingStructField); final _result = _smokeStructsDoublenestingimmutablestructCreateHandle(_nestingStructFieldHandle); smokeStructsNestingimmutablestructReleaseFfiHandle(_nestingStructFieldHandle); return _result; } + Structs_DoubleNestingImmutableStruct smokeStructsDoublenestingimmutablestructFromFfi(Pointer handle) { final _nestingStructFieldHandle = _smokeStructsDoublenestingimmutablestructGetFieldnestingStructField(handle); try { @@ -487,8 +617,11 @@ Structs_DoubleNestingImmutableStruct smokeStructsDoublenestingimmutablestructFro smokeStructsNestingimmutablestructReleaseFfiHandle(_nestingStructFieldHandle); } } + void smokeStructsDoublenestingimmutablestructReleaseFfiHandle(Pointer handle) => _smokeStructsDoublenestingimmutablestructReleaseHandle(handle); + // Nullable Structs_DoubleNestingImmutableStruct + final _smokeStructsDoublenestingimmutablestructCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -501,6 +634,7 @@ final _smokeStructsDoublenestingimmutablestructGetValueNullable = __lib.catchArg Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_DoubleNestingImmutableStruct_get_value_nullable')); + Pointer smokeStructsDoublenestingimmutablestructToFfiNullable(Structs_DoubleNestingImmutableStruct? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsDoublenestingimmutablestructToFfi(value); @@ -508,6 +642,7 @@ Pointer smokeStructsDoublenestingimmutablestructToFfiNullable(Structs_Doub smokeStructsDoublenestingimmutablestructReleaseFfiHandle(_handle); return result; } + Structs_DoubleNestingImmutableStruct? smokeStructsDoublenestingimmutablestructFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsDoublenestingimmutablestructGetValueNullable(handle); @@ -515,14 +650,21 @@ Structs_DoubleNestingImmutableStruct? smokeStructsDoublenestingimmutablestructFr smokeStructsDoublenestingimmutablestructReleaseFfiHandle(_handle); return result; } + void smokeStructsDoublenestingimmutablestructReleaseFfiHandleNullable(Pointer handle) => _smokeStructsDoublenestingimmutablestructReleaseHandleNullable(handle); + // End of Structs_DoubleNestingImmutableStruct "private" section. + class Structs_StructWithArrayOfImmutable { List arrayField; + Structs_StructWithArrayOfImmutable(this.arrayField); } + + // Structs_StructWithArrayOfImmutable "private" section, not exported. + final _smokeStructsStructwitharrayofimmutableCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -535,12 +677,16 @@ final _smokeStructsStructwitharrayofimmutableGetFieldarrayField = __lib.catchArg Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_StructWithArrayOfImmutable_get_field_arrayField')); + + + Pointer smokeStructsStructwitharrayofimmutableToFfi(Structs_StructWithArrayOfImmutable value) { final _arrayFieldHandle = foobarListofSmokeStructsAlltypesstructToFfi(value.arrayField); final _result = _smokeStructsStructwitharrayofimmutableCreateHandle(_arrayFieldHandle); foobarListofSmokeStructsAlltypesstructReleaseFfiHandle(_arrayFieldHandle); return _result; } + Structs_StructWithArrayOfImmutable smokeStructsStructwitharrayofimmutableFromFfi(Pointer handle) { final _arrayFieldHandle = _smokeStructsStructwitharrayofimmutableGetFieldarrayField(handle); try { @@ -551,8 +697,11 @@ Structs_StructWithArrayOfImmutable smokeStructsStructwitharrayofimmutableFromFfi foobarListofSmokeStructsAlltypesstructReleaseFfiHandle(_arrayFieldHandle); } } + void smokeStructsStructwitharrayofimmutableReleaseFfiHandle(Pointer handle) => _smokeStructsStructwitharrayofimmutableReleaseHandle(handle); + // Nullable Structs_StructWithArrayOfImmutable + final _smokeStructsStructwitharrayofimmutableCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -565,6 +714,7 @@ final _smokeStructsStructwitharrayofimmutableGetValueNullable = __lib.catchArgum Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_StructWithArrayOfImmutable_get_value_nullable')); + Pointer smokeStructsStructwitharrayofimmutableToFfiNullable(Structs_StructWithArrayOfImmutable? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsStructwitharrayofimmutableToFfi(value); @@ -572,6 +722,7 @@ Pointer smokeStructsStructwitharrayofimmutableToFfiNullable(Structs_Struct smokeStructsStructwitharrayofimmutableReleaseFfiHandle(_handle); return result; } + Structs_StructWithArrayOfImmutable? smokeStructsStructwitharrayofimmutableFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsStructwitharrayofimmutableGetValueNullable(handle); @@ -579,45 +730,104 @@ Structs_StructWithArrayOfImmutable? smokeStructsStructwitharrayofimmutableFromFf smokeStructsStructwitharrayofimmutableReleaseFfiHandle(_handle); return result; } + void smokeStructsStructwitharrayofimmutableReleaseFfiHandleNullable(Pointer handle) => _smokeStructsStructwitharrayofimmutableReleaseHandleNullable(handle); + // End of Structs_StructWithArrayOfImmutable "private" section. @immutable class Structs_ImmutableStructWithCppAccessors { - final String stringField; - const Structs_ImmutableStructWithCppAccessors(this.stringField); + final int trivialIntField; + + final double trivialDoubleField; + + final String nontrivialStringField; + + final Structs_Point nontrivialPointField; + + final Structs_Point? nontrivialOptionalPoint; + + const Structs_ImmutableStructWithCppAccessors(this.trivialIntField, this.trivialDoubleField, this.nontrivialStringField, this.nontrivialPointField, this.nontrivialOptionalPoint); + const Structs_ImmutableStructWithCppAccessors.withDefaults(int trivialIntField, double trivialDoubleField, String nontrivialStringField, Structs_Point nontrivialPointField) + : trivialIntField = trivialIntField, trivialDoubleField = trivialDoubleField, nontrivialStringField = nontrivialStringField, nontrivialPointField = nontrivialPointField, nontrivialOptionalPoint = null; } + + // Structs_ImmutableStructWithCppAccessors "private" section, not exported. + final _smokeStructsImmutablestructwithcppaccessorsCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< - Pointer Function(Pointer), - Pointer Function(Pointer) + Pointer Function(Int32, Double, Pointer, Pointer, Pointer), + Pointer Function(int, double, Pointer, Pointer, Pointer) >('library_smoke_Structs_ImmutableStructWithCppAccessors_create_handle')); final _smokeStructsImmutablestructwithcppaccessorsReleaseHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Void Function(Pointer), void Function(Pointer) >('library_smoke_Structs_ImmutableStructWithCppAccessors_release_handle')); -final _smokeStructsImmutablestructwithcppaccessorsGetFieldstringField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< +final _smokeStructsImmutablestructwithcppaccessorsGetFieldtrivialIntField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Int32 Function(Pointer), + int Function(Pointer) + >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialIntField')); +final _smokeStructsImmutablestructwithcppaccessorsGetFieldtrivialDoubleField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Double Function(Pointer), + double Function(Pointer) + >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_trivialDoubleField')); +final _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialStringField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) - >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_stringField')); + >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialStringField')); +final _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialPointField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialPointField')); +final _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialOptionalPoint = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_field_nontrivialOptionalPoint')); + + + Pointer smokeStructsImmutablestructwithcppaccessorsToFfi(Structs_ImmutableStructWithCppAccessors value) { - final _stringFieldHandle = stringToFfi(value.stringField); - final _result = _smokeStructsImmutablestructwithcppaccessorsCreateHandle(_stringFieldHandle); - stringReleaseFfiHandle(_stringFieldHandle); + final _trivialIntFieldHandle = (value.trivialIntField); + final _trivialDoubleFieldHandle = (value.trivialDoubleField); + final _nontrivialStringFieldHandle = stringToFfi(value.nontrivialStringField); + final _nontrivialPointFieldHandle = smokeStructsPointToFfi(value.nontrivialPointField); + final _nontrivialOptionalPointHandle = smokeStructsPointToFfiNullable(value.nontrivialOptionalPoint); + final _result = _smokeStructsImmutablestructwithcppaccessorsCreateHandle(_trivialIntFieldHandle, _trivialDoubleFieldHandle, _nontrivialStringFieldHandle, _nontrivialPointFieldHandle, _nontrivialOptionalPointHandle); + + + stringReleaseFfiHandle(_nontrivialStringFieldHandle); + smokeStructsPointReleaseFfiHandle(_nontrivialPointFieldHandle); + smokeStructsPointReleaseFfiHandleNullable(_nontrivialOptionalPointHandle); return _result; } + Structs_ImmutableStructWithCppAccessors smokeStructsImmutablestructwithcppaccessorsFromFfi(Pointer handle) { - final _stringFieldHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldstringField(handle); + final _trivialIntFieldHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldtrivialIntField(handle); + final _trivialDoubleFieldHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldtrivialDoubleField(handle); + final _nontrivialStringFieldHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialStringField(handle); + final _nontrivialPointFieldHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialPointField(handle); + final _nontrivialOptionalPointHandle = _smokeStructsImmutablestructwithcppaccessorsGetFieldnontrivialOptionalPoint(handle); try { return Structs_ImmutableStructWithCppAccessors( - stringFromFfi(_stringFieldHandle) + (_trivialIntFieldHandle), + (_trivialDoubleFieldHandle), + stringFromFfi(_nontrivialStringFieldHandle), + smokeStructsPointFromFfi(_nontrivialPointFieldHandle), + smokeStructsPointFromFfiNullable(_nontrivialOptionalPointHandle) ); } finally { - stringReleaseFfiHandle(_stringFieldHandle); + + + stringReleaseFfiHandle(_nontrivialStringFieldHandle); + smokeStructsPointReleaseFfiHandle(_nontrivialPointFieldHandle); + smokeStructsPointReleaseFfiHandleNullable(_nontrivialOptionalPointHandle); } } + void smokeStructsImmutablestructwithcppaccessorsReleaseFfiHandle(Pointer handle) => _smokeStructsImmutablestructwithcppaccessorsReleaseHandle(handle); + // Nullable Structs_ImmutableStructWithCppAccessors + final _smokeStructsImmutablestructwithcppaccessorsCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -630,6 +840,7 @@ final _smokeStructsImmutablestructwithcppaccessorsGetValueNullable = __lib.catch Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_ImmutableStructWithCppAccessors_get_value_nullable')); + Pointer smokeStructsImmutablestructwithcppaccessorsToFfiNullable(Structs_ImmutableStructWithCppAccessors? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsImmutablestructwithcppaccessorsToFfi(value); @@ -637,6 +848,7 @@ Pointer smokeStructsImmutablestructwithcppaccessorsToFfiNullable(Structs_I smokeStructsImmutablestructwithcppaccessorsReleaseFfiHandle(_handle); return result; } + Structs_ImmutableStructWithCppAccessors? smokeStructsImmutablestructwithcppaccessorsFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsImmutablestructwithcppaccessorsGetValueNullable(handle); @@ -644,44 +856,104 @@ Structs_ImmutableStructWithCppAccessors? smokeStructsImmutablestructwithcppacces smokeStructsImmutablestructwithcppaccessorsReleaseFfiHandle(_handle); return result; } + void smokeStructsImmutablestructwithcppaccessorsReleaseFfiHandleNullable(Pointer handle) => _smokeStructsImmutablestructwithcppaccessorsReleaseHandleNullable(handle); + // End of Structs_ImmutableStructWithCppAccessors "private" section. + class Structs_MutableStructWithCppAccessors { - String stringField; - Structs_MutableStructWithCppAccessors(this.stringField); + int trivialIntField; + + double trivialDoubleField; + + String nontrivialStringField; + + Structs_Point nontrivialPointField; + + Structs_Point? nontrivialOptionalPoint; + + Structs_MutableStructWithCppAccessors._(this.trivialIntField, this.trivialDoubleField, this.nontrivialStringField, this.nontrivialPointField, this.nontrivialOptionalPoint); + Structs_MutableStructWithCppAccessors(int trivialIntField, double trivialDoubleField, String nontrivialStringField, Structs_Point nontrivialPointField) + : trivialIntField = trivialIntField, trivialDoubleField = trivialDoubleField, nontrivialStringField = nontrivialStringField, nontrivialPointField = nontrivialPointField, nontrivialOptionalPoint = null; } + + // Structs_MutableStructWithCppAccessors "private" section, not exported. + final _smokeStructsMutablestructwithcppaccessorsCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< - Pointer Function(Pointer), - Pointer Function(Pointer) + Pointer Function(Int32, Double, Pointer, Pointer, Pointer), + Pointer Function(int, double, Pointer, Pointer, Pointer) >('library_smoke_Structs_MutableStructWithCppAccessors_create_handle')); final _smokeStructsMutablestructwithcppaccessorsReleaseHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Void Function(Pointer), void Function(Pointer) >('library_smoke_Structs_MutableStructWithCppAccessors_release_handle')); -final _smokeStructsMutablestructwithcppaccessorsGetFieldstringField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< +final _smokeStructsMutablestructwithcppaccessorsGetFieldtrivialIntField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Int32 Function(Pointer), + int Function(Pointer) + >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialIntField')); +final _smokeStructsMutablestructwithcppaccessorsGetFieldtrivialDoubleField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Double Function(Pointer), + double Function(Pointer) + >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_trivialDoubleField')); +final _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialStringField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) - >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_stringField')); + >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialStringField')); +final _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialPointField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialPointField')); +final _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialOptionalPoint = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_Structs_MutableStructWithCppAccessors_get_field_nontrivialOptionalPoint')); + + + Pointer smokeStructsMutablestructwithcppaccessorsToFfi(Structs_MutableStructWithCppAccessors value) { - final _stringFieldHandle = stringToFfi(value.stringField); - final _result = _smokeStructsMutablestructwithcppaccessorsCreateHandle(_stringFieldHandle); - stringReleaseFfiHandle(_stringFieldHandle); + final _trivialIntFieldHandle = (value.trivialIntField); + final _trivialDoubleFieldHandle = (value.trivialDoubleField); + final _nontrivialStringFieldHandle = stringToFfi(value.nontrivialStringField); + final _nontrivialPointFieldHandle = smokeStructsPointToFfi(value.nontrivialPointField); + final _nontrivialOptionalPointHandle = smokeStructsPointToFfiNullable(value.nontrivialOptionalPoint); + final _result = _smokeStructsMutablestructwithcppaccessorsCreateHandle(_trivialIntFieldHandle, _trivialDoubleFieldHandle, _nontrivialStringFieldHandle, _nontrivialPointFieldHandle, _nontrivialOptionalPointHandle); + + + stringReleaseFfiHandle(_nontrivialStringFieldHandle); + smokeStructsPointReleaseFfiHandle(_nontrivialPointFieldHandle); + smokeStructsPointReleaseFfiHandleNullable(_nontrivialOptionalPointHandle); return _result; } + Structs_MutableStructWithCppAccessors smokeStructsMutablestructwithcppaccessorsFromFfi(Pointer handle) { - final _stringFieldHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldstringField(handle); + final _trivialIntFieldHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldtrivialIntField(handle); + final _trivialDoubleFieldHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldtrivialDoubleField(handle); + final _nontrivialStringFieldHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialStringField(handle); + final _nontrivialPointFieldHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialPointField(handle); + final _nontrivialOptionalPointHandle = _smokeStructsMutablestructwithcppaccessorsGetFieldnontrivialOptionalPoint(handle); try { - return Structs_MutableStructWithCppAccessors( - stringFromFfi(_stringFieldHandle) + return Structs_MutableStructWithCppAccessors._( + (_trivialIntFieldHandle), + (_trivialDoubleFieldHandle), + stringFromFfi(_nontrivialStringFieldHandle), + smokeStructsPointFromFfi(_nontrivialPointFieldHandle), + smokeStructsPointFromFfiNullable(_nontrivialOptionalPointHandle) ); } finally { - stringReleaseFfiHandle(_stringFieldHandle); + + + stringReleaseFfiHandle(_nontrivialStringFieldHandle); + smokeStructsPointReleaseFfiHandle(_nontrivialPointFieldHandle); + smokeStructsPointReleaseFfiHandleNullable(_nontrivialOptionalPointHandle); } } + void smokeStructsMutablestructwithcppaccessorsReleaseFfiHandle(Pointer handle) => _smokeStructsMutablestructwithcppaccessorsReleaseHandle(handle); + // Nullable Structs_MutableStructWithCppAccessors + final _smokeStructsMutablestructwithcppaccessorsCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Pointer Function(Pointer), Pointer Function(Pointer) @@ -694,6 +966,7 @@ final _smokeStructsMutablestructwithcppaccessorsGetValueNullable = __lib.catchAr Pointer Function(Pointer), Pointer Function(Pointer) >('library_smoke_Structs_MutableStructWithCppAccessors_get_value_nullable')); + Pointer smokeStructsMutablestructwithcppaccessorsToFfiNullable(Structs_MutableStructWithCppAccessors? value) { if (value == null) return Pointer.fromAddress(0); final _handle = smokeStructsMutablestructwithcppaccessorsToFfi(value); @@ -701,6 +974,7 @@ Pointer smokeStructsMutablestructwithcppaccessorsToFfiNullable(Structs_Mut smokeStructsMutablestructwithcppaccessorsReleaseFfiHandle(_handle); return result; } + Structs_MutableStructWithCppAccessors? smokeStructsMutablestructwithcppaccessorsFromFfiNullable(Pointer handle) { if (handle.address == 0) return null; final _handle = _smokeStructsMutablestructwithcppaccessorsGetValueNullable(handle); @@ -708,10 +982,14 @@ Structs_MutableStructWithCppAccessors? smokeStructsMutablestructwithcppaccessors smokeStructsMutablestructwithcppaccessorsReleaseFfiHandle(_handle); return result; } + void smokeStructsMutablestructwithcppaccessorsReleaseFfiHandleNullable(Pointer handle) => _smokeStructsMutablestructwithcppaccessorsReleaseHandleNullable(handle); + // End of Structs_MutableStructWithCppAccessors "private" section. + // Structs "private" section, not exported. + final _smokeStructsRegisterFinalizer = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< Void Function(Pointer, Int32, Handle), void Function(Pointer, int, Object) @@ -724,10 +1002,18 @@ final _smokeStructsReleaseHandle = __lib.catchArgumentError(() => __lib.nativeLi Void Function(Pointer), void Function(Pointer) >('library_smoke_Structs_release_handle')); + + + + + + /// @nodoc @visibleForTesting class Structs$Impl extends __lib.NativeBase implements Structs { + Structs$Impl(Pointer handle) : super(handle); + Structs_Point swapPointCoordinates(Structs_Point input) { final _swapPointCoordinatesFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_Structs_swapPointCoordinates__Point')); final _inputHandle = smokeStructsPointToFfi(input); @@ -737,8 +1023,11 @@ class Structs$Impl extends __lib.NativeBase implements Structs { return smokeStructsPointFromFfi(__resultHandle); } finally { smokeStructsPointReleaseFfiHandle(__resultHandle); + } + } + Structs_AllTypesStruct returnAllTypesStruct(Structs_AllTypesStruct input) { final _returnAllTypesStructFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_Structs_returnAllTypesStruct__AllTypesStruct')); final _inputHandle = smokeStructsAlltypesstructToFfi(input); @@ -748,19 +1037,27 @@ class Structs$Impl extends __lib.NativeBase implements Structs { return smokeStructsAlltypesstructFromFfi(__resultHandle); } finally { smokeStructsAlltypesstructReleaseFfiHandle(__resultHandle); + } + } + TypeCollection_Point createPoint(double x, double y) { final _createPointFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Double, Double), Pointer Function(int, double, double)>('library_smoke_Structs_createPoint__Double_Double')); final _xHandle = (x); final _yHandle = (y); final __resultHandle = _createPointFfi(__lib.LibraryContext.isolateId, _xHandle, _yHandle); + + try { return smokeTypecollectionPointFromFfi(__resultHandle); } finally { smokeTypecollectionPointReleaseFfiHandle(__resultHandle); + } + } + TypeCollection_AllTypesStruct modifyAllTypesStruct(TypeCollection_AllTypesStruct input) { final _modifyAllTypesStructFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_Structs_modifyAllTypesStruct__AllTypesStruct')); final _inputHandle = smokeTypecollectionAlltypesstructToFfi(input); @@ -770,27 +1067,41 @@ class Structs$Impl extends __lib.NativeBase implements Structs { return smokeTypecollectionAlltypesstructFromFfi(__resultHandle); } finally { smokeTypecollectionAlltypesstructReleaseFfiHandle(__resultHandle); + } + } + + } + Pointer smokeStructsToFfi(Structs value) => _smokeStructsCopyHandle((value as __lib.NativeBase).handle); + Structs smokeStructsFromFfi(Pointer handle) { if (handle.address == 0) throw StateError("Expected non-null value."); final instance = __lib.getCachedInstance(handle); if (instance != null && instance is Structs) return instance; + final _copiedHandle = _smokeStructsCopyHandle(handle); final result = Structs$Impl(_copiedHandle); __lib.cacheInstance(_copiedHandle, result); _smokeStructsRegisterFinalizer(_copiedHandle, __lib.LibraryContext.isolateId, result); return result; } + void smokeStructsReleaseFfiHandle(Pointer handle) => _smokeStructsReleaseHandle(handle); + Pointer smokeStructsToFfiNullable(Structs? value) => value != null ? smokeStructsToFfi(value) : Pointer.fromAddress(0); + Structs? smokeStructsFromFfiNullable(Pointer handle) => handle.address != 0 ? smokeStructsFromFfi(handle) : null; + void smokeStructsReleaseFfiHandleNullable(Pointer handle) => _smokeStructsReleaseHandle(handle); + // End of Structs "private" section. + + diff --git a/gluecodium/src/test/resources/smoke/structs/output/swift/smoke/Structs.swift b/gluecodium/src/test/resources/smoke/structs/output/swift/smoke/Structs.swift index e59870841f..b6d348640c 100644 --- a/gluecodium/src/test/resources/smoke/structs/output/swift/smoke/Structs.swift +++ b/gluecodium/src/test/resources/smoke/structs/output/swift/smoke/Structs.swift @@ -1,26 +1,40 @@ // + // + import Foundation + public class Structs { + public typealias ArrayOfImmutable = [Structs.AllTypesStruct] + + let c_instance : _baseRef + init(cStructs: _baseRef) { guard cStructs != 0 else { fatalError("Nullptr value is not supported for initializers") } c_instance = cStructs } + deinit { smoke_Structs_remove_swift_object_from_wrapper_cache(c_instance) smoke_Structs_release_handle(c_instance) } + public enum FooBar : UInt32, CaseIterable, Codable { + case foo + case bar } public struct Point { + public var x: Double + public var y: Double + public init(x: Double, y: Double) { self.x = x self.y = y @@ -30,9 +44,13 @@ public class Structs { y = moveFromCType(smoke_Structs_Point_y_get(cHandle)) } } + public struct Line { + public var a: Structs.Point + public var b: Structs.Point + public init(a: Structs.Point, b: Structs.Point) { self.a = a self.b = b @@ -42,21 +60,37 @@ public class Structs { b = moveFromCType(smoke_Structs_Line_b_get(cHandle)) } } + public struct AllTypesStruct { + public let int8Field: Int8 + public let uint8Field: UInt8 + public let int16Field: Int16 + public let uint16Field: UInt16 + public let int32Field: Int32 + public let uint32Field: UInt32 + public let int64Field: Int64 + public let uint64Field: UInt64 + public let floatField: Float + public let doubleField: Double + public let stringField: String + public let booleanField: Bool + public let bytesField: Data + public let pointField: Structs.Point + public init(int8Field: Int8, uint8Field: UInt8, int16Field: Int16, uint16Field: UInt16, int32Field: Int32, uint32Field: UInt32, int64Field: Int64, uint64Field: UInt64, floatField: Float, doubleField: Double, stringField: String, booleanField: Bool, bytesField: Data, pointField: Structs.Point) { self.int8Field = int8Field self.uint8Field = uint8Field @@ -90,8 +124,11 @@ public class Structs { pointField = moveFromCType(smoke_Structs_AllTypesStruct_pointField_get(cHandle)) } } + public struct NestingImmutableStruct { + public var structField: Structs.AllTypesStruct + public init(structField: Structs.AllTypesStruct) { self.structField = structField } @@ -99,8 +136,11 @@ public class Structs { structField = moveFromCType(smoke_Structs_NestingImmutableStruct_structField_get(cHandle)) } } + public struct DoubleNestingImmutableStruct { + public var nestingStructField: Structs.NestingImmutableStruct + public init(nestingStructField: Structs.NestingImmutableStruct) { self.nestingStructField = nestingStructField } @@ -108,8 +148,11 @@ public class Structs { nestingStructField = moveFromCType(smoke_Structs_DoubleNestingImmutableStruct_nestingStructField_get(cHandle)) } } + public struct StructWithArrayOfImmutable { + public var arrayField: Structs.ArrayOfImmutable + public init(arrayField: Structs.ArrayOfImmutable) { self.arrayField = arrayField } @@ -117,24 +160,63 @@ public class Structs { arrayField = foobar_moveFromCType(smoke_Structs_StructWithArrayOfImmutable_arrayField_get(cHandle)) } } + public struct ImmutableStructWithCppAccessors { - public let stringField: String - public init(stringField: String) { - self.stringField = stringField + + public let trivialIntField: Int32 + + public let trivialDoubleField: Double + + public let nontrivialStringField: String + + public let nontrivialPointField: Structs.Point + + public let nontrivialOptionalPoint: Structs.Point? + + public init(trivialIntField: Int32, trivialDoubleField: Double, nontrivialStringField: String, nontrivialPointField: Structs.Point, nontrivialOptionalPoint: Structs.Point? = nil) { + self.trivialIntField = trivialIntField + self.trivialDoubleField = trivialDoubleField + self.nontrivialStringField = nontrivialStringField + self.nontrivialPointField = nontrivialPointField + self.nontrivialOptionalPoint = nontrivialOptionalPoint } internal init(cHandle: _baseRef) { - stringField = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_stringField_get(cHandle)) + trivialIntField = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_trivialIntField_get(cHandle)) + trivialDoubleField = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_trivialDoubleField_get(cHandle)) + nontrivialStringField = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_nontrivialStringField_get(cHandle)) + nontrivialPointField = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_nontrivialPointField_get(cHandle)) + nontrivialOptionalPoint = moveFromCType(smoke_Structs_ImmutableStructWithCppAccessors_nontrivialOptionalPoint_get(cHandle)) } } + public struct MutableStructWithCppAccessors { - public var stringField: String - public init(stringField: String) { - self.stringField = stringField + + public var trivialIntField: Int32 + + public var trivialDoubleField: Double + + public var nontrivialStringField: String + + public var nontrivialPointField: Structs.Point + + public var nontrivialOptionalPoint: Structs.Point? + + public init(trivialIntField: Int32, trivialDoubleField: Double, nontrivialStringField: String, nontrivialPointField: Structs.Point, nontrivialOptionalPoint: Structs.Point? = nil) { + self.trivialIntField = trivialIntField + self.trivialDoubleField = trivialDoubleField + self.nontrivialStringField = nontrivialStringField + self.nontrivialPointField = nontrivialPointField + self.nontrivialOptionalPoint = nontrivialOptionalPoint } internal init(cHandle: _baseRef) { - stringField = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_stringField_get(cHandle)) + trivialIntField = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_trivialIntField_get(cHandle)) + trivialDoubleField = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_trivialDoubleField_get(cHandle)) + nontrivialStringField = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_nontrivialStringField_get(cHandle)) + nontrivialPointField = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_nontrivialPointField_get(cHandle)) + nontrivialOptionalPoint = moveFromCType(smoke_Structs_MutableStructWithCppAccessors_nontrivialOptionalPoint_get(cHandle)) } } + public static func swapPointCoordinates(input: Structs.Point) -> Structs.Point { let c_input = moveToCType(input) let c_result_handle = smoke_Structs_swapPointCoordinates(c_input.ref) @@ -156,7 +238,11 @@ public class Structs { let c_result_handle = smoke_Structs_modifyAllTypesStruct(c_input.ref) return moveFromCType(c_result_handle) } + } + + + internal func getRef(_ ref: Structs?, owning: Bool = true) -> RefHolder { guard let c_handle = ref?.c_instance else { return RefHolder(0) @@ -166,6 +252,7 @@ internal func getRef(_ ref: Structs?, owning: Bool = true) -> RefHolder { ? RefHolder(ref: handle_copy, release: smoke_Structs_release_handle) : RefHolder(handle_copy) } + extension Structs: NativeBase { /// :nodoc: var c_handle: _baseRef { return c_instance } @@ -175,11 +262,13 @@ extension Structs: Hashable { public static func == (lhs: Structs, rhs: Structs) -> Bool { return lhs.c_handle == rhs.c_handle } + /// :nodoc: public func hash(into hasher: inout Hasher) { hasher.combine(c_handle) } } + internal func Structs_copyFromCType(_ handle: _baseRef) -> Structs { if let swift_pointer = smoke_Structs_get_swift_object_from_wrapper_cache(handle), let re_constructed = Unmanaged.fromOpaque(swift_pointer).takeUnretainedValue() as? Structs { @@ -189,6 +278,7 @@ internal func Structs_copyFromCType(_ handle: _baseRef) -> Structs { smoke_Structs_cache_swift_object_wrapper(handle, Unmanaged.passUnretained(result).toOpaque()) return result } + internal func Structs_moveFromCType(_ handle: _baseRef) -> Structs { if let swift_pointer = smoke_Structs_get_swift_object_from_wrapper_cache(handle), let re_constructed = Unmanaged.fromOpaque(swift_pointer).takeUnretainedValue() as? Structs { @@ -199,6 +289,7 @@ internal func Structs_moveFromCType(_ handle: _baseRef) -> Structs { smoke_Structs_cache_swift_object_wrapper(handle, Unmanaged.passUnretained(result).toOpaque()) return result } + internal func Structs_copyFromCType(_ handle: _baseRef) -> Structs? { guard handle != 0 else { return nil @@ -211,18 +302,23 @@ internal func Structs_moveFromCType(_ handle: _baseRef) -> Structs? { } return Structs_moveFromCType(handle) as Structs } + internal func copyToCType(_ swiftClass: Structs) -> RefHolder { return getRef(swiftClass, owning: false) } + internal func moveToCType(_ swiftClass: Structs) -> RefHolder { return getRef(swiftClass, owning: true) } + internal func copyToCType(_ swiftClass: Structs?) -> RefHolder { return getRef(swiftClass, owning: false) } + internal func moveToCType(_ swiftClass: Structs?) -> RefHolder { return getRef(swiftClass, owning: true) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.Point { return Structs.Point(cHandle: handle) } @@ -232,6 +328,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.Point { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.Point) -> RefHolder { let c_x = moveToCType(swiftType.x) let c_y = moveToCType(swiftType.y) @@ -253,6 +350,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.Point? { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.Point?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -264,6 +362,7 @@ internal func copyToCType(_ swiftType: Structs.Point?) -> RefHolder { internal func moveToCType(_ swiftType: Structs.Point?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_Point_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.Line { return Structs.Line(cHandle: handle) } @@ -273,6 +372,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.Line { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.Line) -> RefHolder { let c_a = moveToCType(swiftType.a) let c_b = moveToCType(swiftType.b) @@ -294,6 +394,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.Line? { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.Line?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -305,6 +406,7 @@ internal func copyToCType(_ swiftType: Structs.Line?) -> RefHolder { internal func moveToCType(_ swiftType: Structs.Line?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_Line_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.AllTypesStruct { return Structs.AllTypesStruct(cHandle: handle) } @@ -314,6 +416,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.AllTypesStruct { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.AllTypesStruct) -> RefHolder { let c_int8Field = moveToCType(swiftType.int8Field) let c_uint8Field = moveToCType(swiftType.uint8Field) @@ -347,6 +450,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.AllTypesStruct? { } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.AllTypesStruct?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -370,6 +474,7 @@ internal func copyToCType(_ swiftType: Structs.AllTypesStruct?) -> RefHolder { internal func moveToCType(_ swiftType: Structs.AllTypesStruct?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_AllTypesStruct_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.NestingImmutableStruct { return Structs.NestingImmutableStruct(cHandle: handle) } @@ -379,6 +484,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.NestingImmutableStruc } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.NestingImmutableStruct) -> RefHolder { let c_structField = moveToCType(swiftType.structField) return RefHolder(smoke_Structs_NestingImmutableStruct_create_handle(c_structField.ref)) @@ -399,6 +505,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.NestingImmutableStruc } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.NestingImmutableStruct?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -409,6 +516,7 @@ internal func copyToCType(_ swiftType: Structs.NestingImmutableStruct?) -> RefHo internal func moveToCType(_ swiftType: Structs.NestingImmutableStruct?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_NestingImmutableStruct_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.DoubleNestingImmutableStruct { return Structs.DoubleNestingImmutableStruct(cHandle: handle) } @@ -418,6 +526,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.DoubleNestingImmutabl } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.DoubleNestingImmutableStruct) -> RefHolder { let c_nestingStructField = moveToCType(swiftType.nestingStructField) return RefHolder(smoke_Structs_DoubleNestingImmutableStruct_create_handle(c_nestingStructField.ref)) @@ -438,6 +547,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.DoubleNestingImmutabl } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.DoubleNestingImmutableStruct?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -448,6 +558,7 @@ internal func copyToCType(_ swiftType: Structs.DoubleNestingImmutableStruct?) -> internal func moveToCType(_ swiftType: Structs.DoubleNestingImmutableStruct?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_DoubleNestingImmutableStruct_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.StructWithArrayOfImmutable { return Structs.StructWithArrayOfImmutable(cHandle: handle) } @@ -457,6 +568,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.StructWithArrayOfImmu } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.StructWithArrayOfImmutable) -> RefHolder { let c_arrayField = foobar_moveToCType(swiftType.arrayField) return RefHolder(smoke_Structs_StructWithArrayOfImmutable_create_handle(c_arrayField.ref)) @@ -477,6 +589,7 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.StructWithArrayOfImmu } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.StructWithArrayOfImmutable?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) @@ -487,6 +600,7 @@ internal func copyToCType(_ swiftType: Structs.StructWithArrayOfImmutable?) -> R internal func moveToCType(_ swiftType: Structs.StructWithArrayOfImmutable?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_StructWithArrayOfImmutable_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.ImmutableStructWithCppAccessors { return Structs.ImmutableStructWithCppAccessors(cHandle: handle) } @@ -496,9 +610,14 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.ImmutableStructWithCp } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.ImmutableStructWithCppAccessors) -> RefHolder { - let c_stringField = moveToCType(swiftType.stringField) - return RefHolder(smoke_Structs_ImmutableStructWithCppAccessors_create_handle(c_stringField.ref)) + let c_trivialIntField = moveToCType(swiftType.trivialIntField) + let c_trivialDoubleField = moveToCType(swiftType.trivialDoubleField) + let c_nontrivialStringField = moveToCType(swiftType.nontrivialStringField) + let c_nontrivialPointField = moveToCType(swiftType.nontrivialPointField) + let c_nontrivialOptionalPoint = moveToCType(swiftType.nontrivialOptionalPoint) + return RefHolder(smoke_Structs_ImmutableStructWithCppAccessors_create_handle(c_trivialIntField.ref, c_trivialDoubleField.ref, c_nontrivialStringField.ref, c_nontrivialPointField.ref, c_nontrivialOptionalPoint.ref)) } internal func moveToCType(_ swiftType: Structs.ImmutableStructWithCppAccessors) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_ImmutableStructWithCppAccessors_release_handle) @@ -516,16 +635,22 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.ImmutableStructWithCp } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.ImmutableStructWithCppAccessors?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) } - let c_stringField = moveToCType(swiftType.stringField) - return RefHolder(smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(c_stringField.ref)) + let c_trivialIntField = moveToCType(swiftType.trivialIntField) + let c_trivialDoubleField = moveToCType(swiftType.trivialDoubleField) + let c_nontrivialStringField = moveToCType(swiftType.nontrivialStringField) + let c_nontrivialPointField = moveToCType(swiftType.nontrivialPointField) + let c_nontrivialOptionalPoint = moveToCType(swiftType.nontrivialOptionalPoint) + return RefHolder(smoke_Structs_ImmutableStructWithCppAccessors_create_optional_handle(c_trivialIntField.ref, c_trivialDoubleField.ref, c_nontrivialStringField.ref, c_nontrivialPointField.ref, c_nontrivialOptionalPoint.ref)) } internal func moveToCType(_ swiftType: Structs.ImmutableStructWithCppAccessors?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_ImmutableStructWithCppAccessors_release_optional_handle) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.MutableStructWithCppAccessors { return Structs.MutableStructWithCppAccessors(cHandle: handle) } @@ -535,9 +660,14 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.MutableStructWithCppA } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.MutableStructWithCppAccessors) -> RefHolder { - let c_stringField = moveToCType(swiftType.stringField) - return RefHolder(smoke_Structs_MutableStructWithCppAccessors_create_handle(c_stringField.ref)) + let c_trivialIntField = moveToCType(swiftType.trivialIntField) + let c_trivialDoubleField = moveToCType(swiftType.trivialDoubleField) + let c_nontrivialStringField = moveToCType(swiftType.nontrivialStringField) + let c_nontrivialPointField = moveToCType(swiftType.nontrivialPointField) + let c_nontrivialOptionalPoint = moveToCType(swiftType.nontrivialOptionalPoint) + return RefHolder(smoke_Structs_MutableStructWithCppAccessors_create_handle(c_trivialIntField.ref, c_trivialDoubleField.ref, c_nontrivialStringField.ref, c_nontrivialPointField.ref, c_nontrivialOptionalPoint.ref)) } internal func moveToCType(_ swiftType: Structs.MutableStructWithCppAccessors) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_MutableStructWithCppAccessors_release_handle) @@ -555,34 +685,43 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.MutableStructWithCppA } return copyFromCType(handle) } + internal func copyToCType(_ swiftType: Structs.MutableStructWithCppAccessors?) -> RefHolder { guard let swiftType = swiftType else { return RefHolder(0) } - let c_stringField = moveToCType(swiftType.stringField) - return RefHolder(smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(c_stringField.ref)) + let c_trivialIntField = moveToCType(swiftType.trivialIntField) + let c_trivialDoubleField = moveToCType(swiftType.trivialDoubleField) + let c_nontrivialStringField = moveToCType(swiftType.nontrivialStringField) + let c_nontrivialPointField = moveToCType(swiftType.nontrivialPointField) + let c_nontrivialOptionalPoint = moveToCType(swiftType.nontrivialOptionalPoint) + return RefHolder(smoke_Structs_MutableStructWithCppAccessors_create_optional_handle(c_trivialIntField.ref, c_trivialDoubleField.ref, c_nontrivialStringField.ref, c_nontrivialPointField.ref, c_nontrivialOptionalPoint.ref)) } internal func moveToCType(_ swiftType: Structs.MutableStructWithCppAccessors?) -> RefHolder { return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_Structs_MutableStructWithCppAccessors_release_optional_handle) } + internal func copyToCType(_ swiftEnum: Structs.FooBar) -> PrimitiveHolder { return PrimitiveHolder(swiftEnum.rawValue) } internal func moveToCType(_ swiftEnum: Structs.FooBar) -> PrimitiveHolder { return copyToCType(swiftEnum) } + internal func copyToCType(_ swiftEnum: Structs.FooBar?) -> RefHolder { return copyToCType(swiftEnum?.rawValue) } internal func moveToCType(_ swiftEnum: Structs.FooBar?) -> RefHolder { return moveToCType(swiftEnum?.rawValue) } + internal func copyFromCType(_ cValue: UInt32) -> Structs.FooBar { return Structs.FooBar(rawValue: cValue)! } internal func moveFromCType(_ cValue: UInt32) -> Structs.FooBar { return copyFromCType(cValue) } + internal func copyFromCType(_ handle: _baseRef) -> Structs.FooBar? { guard handle != 0 else { return nil @@ -595,3 +734,5 @@ internal func moveFromCType(_ handle: _baseRef) -> Structs.FooBar? { } return copyFromCType(handle) } + +