Support fixed-size arrays in the CPP backend
Fixed-size arrays are represented with std::array<T,N> and
(de)serialized with Parcel::readFixedArray/writeFixedArray APIs.
Bug: 207087196
Test: aidl_integration_test
Change-Id: Ied4abbcdac537278900772a3084f071d802d1a6c
diff --git a/Android.bp b/Android.bp
index 896c8c1..37a3c90 100644
--- a/Android.bp
+++ b/Android.bp
@@ -376,6 +376,7 @@
// service uses the old version
"aidl-test-versioned-interface-V1-cpp",
"aidl_test_loggable_interface-cpp",
+ "aidl-test-fixedsizearray-cpp",
],
srcs: ["tests/aidl_test_service.cpp"],
}
@@ -390,6 +391,7 @@
// client uses the latest version
"aidl-test-versioned-interface-V2-cpp",
"aidl_test_loggable_interface-cpp",
+ "aidl-test-fixedsizearray-cpp",
],
srcs: [
"tests/aidl_test_client.cpp",
@@ -442,7 +444,8 @@
unstable: true,
backend: {
cpp: {
- enabled: false,
+ enabled: true,
+ srcs_available: true,
},
java: {
enabled: false,
@@ -628,6 +631,7 @@
":aidl_test_loggable_interface-java-source",
":aidl_test_loggable_interface-ndk-source",
":aidl-test-interface-platform-java-source",
+ ":aidl-test-fixedsizearray-cpp-source",
":aidl-test-fixedsizearray-ndk-source",
"tests/golden_output/**/*",
],
diff --git a/aidl_to_cpp.cpp b/aidl_to_cpp.cpp
index 422a2e5..b643f41 100644
--- a/aidl_to_cpp.cpp
+++ b/aidl_to_cpp.cpp
@@ -35,6 +35,9 @@
namespace cpp {
namespace {
+static const AidlTypeSpecifier kIntType{AIDL_LOCATION_HERE, "int", /*array=*/std::nullopt, nullptr,
+ Comments{}};
+
std::string RawParcelMethod(const AidlTypeSpecifier& type, const AidlTypenames& typenames,
bool readMethod) {
static map<string, string> kBuiltin = {
@@ -70,6 +73,10 @@
const bool isVector = type.IsArray() || typenames.IsList(type);
const bool utf8 = type.IsUtf8InCpp();
+ if (type.IsFixedSizeArray()) {
+ return "FixedArray";
+ }
+
if (auto enum_decl = typenames.GetEnumDeclaration(type); enum_decl != nullptr) {
if (isVector) {
return "EnumVector";
@@ -211,16 +218,28 @@
}
std::string CppNameOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames) {
+ // get base type's cpp_name with nullable processed.
+ std::string cpp_name = GetCppName(type, typenames);
+
if (type.IsArray() || typenames.IsList(type)) {
- std::string cpp_name = GetCppName(type, typenames);
- if (type.IsHeapNullable()) {
- return "::std::unique_ptr<::std::vector<" + cpp_name + ">>";
- } else if (type.IsNullable()) {
- return "::std::optional<::std::vector<" + cpp_name + ">>";
+ if (type.IsFixedSizeArray()) {
+ for (const auto& dim : std::get<FixedSizeArray>(type.GetArray()).dimensions) {
+ cpp_name = "std::array<" + cpp_name + ", " +
+ dim->ValueString(kIntType, ConstantValueDecorator) + ">";
+ }
+ } else {
+ cpp_name = "::std::vector<" + cpp_name + ">";
}
- return "::std::vector<" + cpp_name + ">";
+
+ // wrap nullable again because @nullable applies to BOTH array type(outermost type) AND base
+ // type(innermost type)
+ if (type.IsHeapNullable()) {
+ cpp_name = "::std::unique_ptr<" + cpp_name + ">";
+ } else if (type.IsNullable()) {
+ cpp_name = "::std::optional<" + cpp_name + ">";
+ }
}
- return GetCppName(type, typenames);
+ return cpp_name;
}
bool IsNonCopyableType(const AidlTypeSpecifier& type, const AidlTypenames& typenames) {
@@ -269,25 +288,28 @@
// Add includes for a type ref. Note that this is non-recursive.
void AddHeaders(const AidlTypeSpecifier& type, const AidlTypenames& typenames,
std::set<std::string>* headers) {
- AIDL_FATAL_IF(typenames.IsList(type) && type.GetTypeParameters().size() != 1, type);
- bool isVector = type.IsArray() || typenames.IsList(type);
- bool isNullable = type.IsNullable();
- bool utf8 = type.IsUtf8InCpp();
-
- if (isVector) {
- headers->insert("vector");
+ if (type.IsArray()) {
+ if (type.IsFixedSizeArray()) {
+ headers->insert("array");
+ } else {
+ headers->insert("vector");
+ }
}
- if (isNullable) {
+ if (type.IsNullable()) {
if (type.GetName() != "IBinder") {
headers->insert("optional");
}
}
if (typenames.IsList(type)) {
- // Nothing else to do for List.
+ headers->insert("vector");
return;
}
if (type.GetName() == "String") {
- headers->insert(utf8 ? "string" : "utils/String16.h");
+ if (type.IsUtf8InCpp()) {
+ headers->insert("string");
+ } else {
+ headers->insert("utils/String16.h");
+ }
return;
}
if (type.GetName() == "IBinder") {
diff --git a/aidl_unittest.cpp b/aidl_unittest.cpp
index 9010e0d..8472373 100644
--- a/aidl_unittest.cpp
+++ b/aidl_unittest.cpp
@@ -5205,7 +5205,7 @@
{"java_primitiveArray", {"", ""}},
{"ndk_primitiveArray", {"", ""}},
{"rust_primitiveArray", {"", ""}},
- {"cpp_primitiveFixedArray", {"not supported yet", "not supported yet"}},
+ {"cpp_primitiveFixedArray", {"", ""}},
{"java_primitiveFixedArray", {"not supported yet", "not supported yet"}},
{"ndk_primitiveFixedArray", {"", ""}},
{"rust_primitiveFixedArray", {"not supported yet", "not supported yet"}},
diff --git a/check_valid.cpp b/check_valid.cpp
index 4dccf52..275504d 100644
--- a/check_valid.cpp
+++ b/check_valid.cpp
@@ -83,7 +83,7 @@
if (options.GetTask() == Options::Task::COMPILE) {
v.Check([&](const AidlTypeSpecifier& type) {
if (type.IsFixedSizeArray()) {
- if (lang != Options::Language::NDK) {
+ if (lang != Options::Language::NDK && lang != Options::Language::CPP) {
AIDL_ERROR(type) << "Fixed-size arrays are not supported yet in " << to_string(lang)
<< " backend.";
return false;
diff --git a/generate_cpp.cpp b/generate_cpp.cpp
index 4c34f9c..eee6a25 100644
--- a/generate_cpp.cpp
+++ b/generate_cpp.cpp
@@ -214,7 +214,7 @@
ParcelWriteMethodOf(a->GetType(), typenames).c_str(),
ParcelWriteCastOf(a->GetType(), typenames, var_name).c_str());
GenerateGotoErrorOnBadStatus(out);
- } else if (a->IsOut() && a->GetType().IsArray()) {
+ } else if (a->IsOut() && a->GetType().IsDynamicArray()) {
// Special case, the length of the out array is written into the parcel.
// _aidl_ret_status = _aidl_data.writeVectorSize(&out_param_name);
// if (_aidl_ret_status != ::android::OK) { goto error; }
@@ -480,7 +480,7 @@
ParcelReadMethodOf(a->GetType(), typenames).c_str(),
ParcelReadCastOf(a->GetType(), typenames, var_name).c_str());
GenerateBreakOnStatusNotOk(out);
- } else if (a->IsOut() && a->GetType().IsArray()) {
+ } else if (a->IsOut() && a->GetType().IsDynamicArray()) {
// Special case, the length of the out array is written into the parcel.
// _aidl_ret_status = _aidl_data.resizeOutVector(&out_param_name);
// if (_aidl_ret_status != ::android::OK) { break; }
diff --git a/tests/aidl_test_client_ndk_parcelables.cpp b/tests/aidl_test_client_ndk_parcelables.cpp
index bc2facc..49cbfae 100644
--- a/tests/aidl_test_client_ndk_parcelables.cpp
+++ b/tests/aidl_test_client_ndk_parcelables.cpp
@@ -34,6 +34,9 @@
using IntParcelable = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable;
using IRepeatFixedSizeArray =
aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IRepeatFixedSizeArray;
+using BnEmptyInterface =
+ aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::BnEmptyInterface;
+using aidl::android::aidl::tests::BackendType;
using aidl::android::aidl::tests::ITestService;
using aidl::android::aidl::tests::RecursiveList;
using android::OK;
@@ -147,70 +150,10 @@
AParcel_delete(parcel);
}
-struct MyService : FixedSizeArrayExample::BnRepeatFixedSizeArray {
- ScopedAStatus RepeatBytes(const std::array<uint8_t, 3>& in_input,
- std::array<uint8_t, 3>* out_repeated,
- std::array<uint8_t, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus RepeatInts(const std::array<int32_t, 3>& in_input,
- std::array<int32_t, 3>* out_repeated,
- std::array<int32_t, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input,
- std::array<::ndk::SpAIBinder, 3>* out_repeated,
- std::array<::ndk::SpAIBinder, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus RepeatParcelables(const std::array<IntParcelable, 3>& in_input,
- std::array<IntParcelable, 3>* out_repeated,
- std::array<IntParcelable, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& in_input,
- std::array<std::array<uint8_t, 2>, 3>* out_repeated,
- std::array<std::array<uint8_t, 2>, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& in_input,
- std::array<std::array<int32_t, 2>, 3>* out_repeated,
- std::array<std::array<int32_t, 2>, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus Repeat2dBinders(const std::array<std::array<::ndk::SpAIBinder, 2>, 3>& in_input,
- std::array<std::array<::ndk::SpAIBinder, 2>, 3>* out_repeated,
- std::array<std::array<::ndk::SpAIBinder, 2>, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
- ScopedAStatus Repeat2dParcelables(const std::array<std::array<IntParcelable, 2>, 3>& in_input,
- std::array<std::array<IntParcelable, 2>, 3>* out_repeated,
- std::array<std::array<IntParcelable, 2>, 3>* _aidl_return) {
- *out_repeated = in_input;
- *_aidl_return = in_input;
- return ScopedAStatus::ok();
- }
-};
-
template <typename Service, typename MemFn, typename Input>
void CheckRepeat(Service service, MemFn fn, Input input) {
- auto proxy = SharedRefBase::make<BpRepeatFixedSizeArray>(service->asBinder());
Input out1, out2;
- EXPECT_TRUE(std::invoke(fn, *proxy, input, &out1, &out2).isOk());
+ EXPECT_TRUE(std::invoke(fn, service, input, &out1, &out2).isOk());
EXPECT_EQ(input, out1);
EXPECT_EQ(input, out2);
}
@@ -229,15 +172,21 @@
}
TEST_F(AidlTest, FixedSizeArrayOverBinder) {
- auto service = SharedRefBase::make<MyService>();
+ auto test_service = getService<ITestService>();
+ BackendType backend;
+ auto status = test_service->getBackendType(&backend);
+ EXPECT_TRUE(status.isOk());
+ if (backend != BackendType::CPP) GTEST_SKIP();
+
+ auto service = getService<IRepeatFixedSizeArray>();
CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBytes, (std::array<uint8_t, 3>{1, 2, 3}));
CheckRepeat(service, &IRepeatFixedSizeArray::RepeatInts, (std::array<int32_t, 3>{1, 2, 3}));
- auto binder1 = SharedRefBase::make<MyService>()->asBinder();
- auto binder2 = SharedRefBase::make<MyService>()->asBinder();
- auto binder3 = service->asBinder();
+ auto binder1 = SharedRefBase::make<BnEmptyInterface>()->asBinder();
+ auto binder2 = SharedRefBase::make<BnEmptyInterface>()->asBinder();
+ auto binder3 = SharedRefBase::make<BnEmptyInterface>()->asBinder();
CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBinders,
(std::array<SpAIBinder, 3>{binder1, binder2, binder3}));
diff --git a/tests/aidl_test_client_parcelables.cpp b/tests/aidl_test_client_parcelables.cpp
index 48cb8b0..ea7394a 100644
--- a/tests/aidl_test_client_parcelables.cpp
+++ b/tests/aidl_test_client_parcelables.cpp
@@ -14,11 +14,13 @@
* limitations under the License.
*/
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
#include <android/aidl/tests/ParcelableForToString.h>
#include <android/aidl/tests/extension/MyExt.h>
#include <android/aidl/tests/extension/MyExt2.h>
#include <android/aidl/tests/extension/MyExtLike.h>
#include <android/aidl/tests/unions/EnumUnion.h>
+#include <binder/Binder.h>
#include "aidl_test_client.h"
#include <string>
@@ -27,6 +29,7 @@
using android::IInterface;
using android::sp;
using android::String16;
+using android::aidl::fixedsizearray::FixedSizeArrayExample;
using android::aidl::tests::ConstantExpressionEnum;
using android::aidl::tests::GenericStructuredParcelable;
using android::aidl::tests::INamedCallback;
@@ -43,6 +46,12 @@
using android::aidl::tests::extension::MyExt2;
using android::aidl::tests::extension::MyExtLike;
using android::aidl::tests::unions::EnumUnion;
+using IntParcelable = android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable;
+using IRepeatFixedSizeArray =
+ android::aidl::fixedsizearray::FixedSizeArrayExample::IRepeatFixedSizeArray;
+using android::BBinder;
+using android::IBinder;
+using android::OK;
using android::binder::Status;
using android::os::PersistableBundle;
using std::string;
@@ -544,3 +553,127 @@
}
EXPECT_EQ(nullptr, cur);
}
+
+TEST_F(AidlTest, FixedSizeArray) {
+ android::Parcel parcel;
+
+ FixedSizeArrayExample p;
+ p.byteMatrix[0][0] = 0;
+ p.byteMatrix[0][1] = 1;
+ p.byteMatrix[1][0] = 2;
+ p.byteMatrix[1][1] = 3;
+ p.floatMatrix[0][0] = 0.f;
+ p.floatMatrix[0][1] = 1.f;
+ p.floatMatrix[1][0] = 2.f;
+ p.floatMatrix[1][1] = 3.f;
+ EXPECT_EQ(OK, p.writeToParcel(&parcel));
+
+ parcel.setDataPosition(0);
+
+ FixedSizeArrayExample q;
+ EXPECT_EQ(OK, q.readFromParcel(&parcel));
+ EXPECT_EQ(p, q);
+}
+
+TEST_F(AidlTest, FixedSizeArrayWithValuesAtNullableFields) {
+ android::Parcel parcel;
+
+ FixedSizeArrayExample p;
+ p.boolNullableArray = std::array<bool, 2>{true, false};
+ p.byteNullableArray = std::array<uint8_t, 2>{42, 0};
+ p.stringNullableArray = std::array<std::optional<std::string>, 2>{"hello", "world"};
+
+ p.boolNullableMatrix.emplace();
+ p.boolNullableMatrix->at(0) = std::array<bool, 2>{true, false};
+ p.byteNullableMatrix.emplace();
+ p.byteNullableMatrix->at(0) = std::array<uint8_t, 2>{42, 0};
+ p.stringNullableMatrix.emplace();
+ p.stringNullableMatrix->at(0) = std::array<std::optional<std::string>, 2>{"hello", "world"};
+
+ EXPECT_EQ(OK, p.writeToParcel(&parcel));
+
+ parcel.setDataPosition(0);
+
+ FixedSizeArrayExample q;
+ EXPECT_EQ(OK, q.readFromParcel(&parcel));
+ EXPECT_EQ(p, q);
+}
+
+TEST_F(AidlTest, FixedSizeArrayOfBytesShouldBePacked) {
+ android::Parcel parcel;
+
+ std::array<std::array<uint8_t, 3>, 2> byte_array;
+ byte_array[0] = {1, 2, 3};
+ byte_array[1] = {4, 5, 6};
+ EXPECT_EQ(OK, parcel.writeFixedArray(byte_array));
+
+ parcel.setDataPosition(0);
+
+ int32_t len;
+ EXPECT_EQ(OK, parcel.readInt32(&len));
+ EXPECT_EQ(2, len);
+ std::vector<uint8_t> byte_vector;
+ EXPECT_EQ(OK, parcel.readByteVector(&byte_vector));
+ EXPECT_EQ(byte_vector, (std::vector<uint8_t>{1, 2, 3}));
+ EXPECT_EQ(OK, parcel.readByteVector(&byte_vector));
+ EXPECT_EQ(byte_vector, (std::vector<uint8_t>{4, 5, 6}));
+}
+
+template <typename Service, typename MemFn, typename Input>
+void CheckRepeat(Service service, MemFn fn, Input input) {
+ Input out1, out2;
+ EXPECT_TRUE(std::invoke(fn, service, input, &out1, &out2).isOk());
+ EXPECT_EQ(input, out1);
+ EXPECT_EQ(input, out2);
+}
+
+template <typename T>
+std::array<std::array<T, 2>, 3> Make2dArray(std::initializer_list<T> values) {
+ std::array<std::array<T, 2>, 3> arr = {};
+ auto it = std::begin(values);
+ for (auto& row : arr) {
+ for (auto& el : row) {
+ if (it == std::end(values)) break;
+ el = *it++;
+ }
+ }
+ return arr;
+}
+
+TEST_F(AidlTest, FixedSizeArrayOverBinder) {
+ BackendType backend;
+ auto status = service->getBackendType(&backend);
+ EXPECT_TRUE(status.isOk());
+ if (backend != BackendType::CPP) GTEST_SKIP();
+
+ sp<IRepeatFixedSizeArray> service;
+ ASSERT_EQ(OK, getService(IRepeatFixedSizeArray::descriptor, &service));
+
+ CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBytes, (std::array<uint8_t, 3>{1, 2, 3}));
+
+ CheckRepeat(service, &IRepeatFixedSizeArray::RepeatInts, (std::array<int32_t, 3>{1, 2, 3}));
+
+ sp<IBinder> binder1 = new BBinder();
+ sp<IBinder> binder2 = new BBinder();
+ sp<IBinder> binder3 = new BBinder();
+ CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBinders,
+ (std::array<sp<IBinder>, 3>{binder1, binder2, binder3}));
+
+ IntParcelable p1, p2, p3;
+ p1.value = 1;
+ p2.value = 2;
+ p3.value = 3;
+ CheckRepeat(service, &IRepeatFixedSizeArray::RepeatParcelables,
+ (std::array<IntParcelable, 3>{p1, p2, p3}));
+
+ CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBytes, Make2dArray<uint8_t>({1, 2, 3}));
+
+ CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dInts, Make2dArray<int32_t>({1, 2, 3}));
+
+ // Not-nullable
+ CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBinders,
+ Make2dArray<sp<IBinder>>({binder1, binder2, binder3, binder1, binder2, binder3}));
+
+ CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dParcelables,
+ Make2dArray<IntParcelable>({p1, p2, p3}));
+}
\ No newline at end of file
diff --git a/tests/aidl_test_service.cpp b/tests/aidl_test_service.cpp
index 76ef2b9..9610b23 100644
--- a/tests/aidl_test_service.cpp
+++ b/tests/aidl_test_service.cpp
@@ -59,6 +59,8 @@
#include "android/aidl/loggable/BnLoggableInterface.h"
#include "android/aidl/loggable/Data.h"
+#include "android/aidl/fixedsizearray/FixedSizeArrayExample.h"
+
// Used implicitly.
#undef LOG_TAG
#define LOG_TAG "aidl_native_service"
@@ -831,6 +833,70 @@
}
};
+using android::aidl::fixedsizearray::FixedSizeArrayExample;
+class FixedSizeArrayService : public FixedSizeArrayExample::BnRepeatFixedSizeArray {
+ public:
+ FixedSizeArrayService() {}
+ virtual ~FixedSizeArrayService() = default;
+
+ Status RepeatBytes(const std::array<uint8_t, 3>& in_input, std::array<uint8_t, 3>* out_repeated,
+ std::array<uint8_t, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status RepeatInts(const std::array<int32_t, 3>& in_input, std::array<int32_t, 3>* out_repeated,
+ std::array<int32_t, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status RepeatBinders(const std::array<sp<IBinder>, 3>& in_input,
+ std::array<sp<IBinder>, 3>* out_repeated,
+ std::array<sp<IBinder>, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status RepeatParcelables(
+ const std::array<FixedSizeArrayExample::IntParcelable, 3>& in_input,
+ std::array<FixedSizeArrayExample::IntParcelable, 3>* out_repeated,
+ std::array<FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& in_input,
+ std::array<std::array<uint8_t, 2>, 3>* out_repeated,
+ std::array<std::array<uint8_t, 2>, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& in_input,
+ std::array<std::array<int32_t, 2>, 3>* out_repeated,
+ std::array<std::array<int32_t, 2>, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status Repeat2dBinders(const std::array<std::array<sp<IBinder>, 2>, 3>& in_input,
+ std::array<std::array<sp<IBinder>, 2>, 3>* out_repeated,
+ std::array<std::array<sp<IBinder>, 2>, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+ Status Repeat2dParcelables(
+ const std::array<std::array<FixedSizeArrayExample::IntParcelable, 2>, 3>& in_input,
+ std::array<std::array<FixedSizeArrayExample::IntParcelable, 2>, 3>* out_repeated,
+ std::array<std::array<FixedSizeArrayExample::IntParcelable, 2>, 3>* _aidl_return) override {
+ *out_repeated = in_input;
+ *_aidl_return = in_input;
+ return Status::ok();
+ }
+};
+
int Run() {
android::sp<NativeService> service = new NativeService;
sp<Looper> looper(Looper::prepare(0 /* opts */));
@@ -880,6 +946,15 @@
return -1;
}
+ android::sp<FixedSizeArrayService> fixedSizeArrayService = new FixedSizeArrayService;
+ status = defaultServiceManager()->addService(fixedSizeArrayService->getInterfaceDescriptor(),
+ fixedSizeArrayService);
+ if (status != OK) {
+ ALOGE("Failed to add service %s",
+ String8(fixedSizeArrayService->getInterfaceDescriptor()).c_str());
+ return -1;
+ }
+
ALOGI("Entering loop");
while (true) {
const int result = looper->pollAll(-1 /* timeoutMillis */);
diff --git a/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl b/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl
index 7a09338..970b8bb 100644
--- a/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl
+++ b/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl
@@ -24,7 +24,7 @@
long[2] longArray;
float[2] floatArray;
double[2] doubleArray;
- String[2] stringArray;
+ @utf8InCpp String[2] stringArray;
ByteEnum[2] byteEnumArray;
IntEnum[2] intEnumArray;
LongEnum[2] longEnumArray;
@@ -41,7 +41,7 @@
long[2][2] longMatrix;
float[2][2] floatMatrix;
double[2][2] doubleMatrix;
- String[2][2] stringMatrix;
+ @utf8InCpp String[2][2] stringMatrix;
ByteEnum[2][2] byteEnumMatrix;
IntEnum[2][2] intEnumMatrix;
LongEnum[2][2] longEnumMatrix;
@@ -58,7 +58,7 @@
@nullable long[2] longNullableArray;
@nullable float[2] floatNullableArray;
@nullable double[2] doubleNullableArray;
- @nullable String[2] stringNullableArray;
+ @nullable @utf8InCpp String[2] stringNullableArray;
@nullable ByteEnum[2] byteEnumNullableArray;
@nullable IntEnum[2] intEnumNullableArray;
@nullable LongEnum[2] longEnumNullableArray;
@@ -74,7 +74,7 @@
@nullable long[2][2] longNullableMatrix;
@nullable float[2][2] floatNullableMatrix;
@nullable double[2][2] doubleNullableMatrix;
- @nullable String[2][2] stringNullableMatrix;
+ @nullable @utf8InCpp String[2][2] stringNullableMatrix;
@nullable ByteEnum[2][2] byteEnumNullableMatrix;
@nullable IntEnum[2][2] intEnumNullableMatrix;
@nullable LongEnum[2][2] longEnumNullableMatrix;
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp
new file mode 100644
index 0000000..a7b2746
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp
@@ -0,0 +1,1404 @@
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+::android::status_t FixedSizeArrayExample::readFromParcel(const ::android::Parcel* _aidl_parcel) {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ [[maybe_unused]] size_t _aidl_start_pos = _aidl_parcel->dataPosition();
+ int32_t _aidl_parcelable_raw_size = _aidl_parcel->readInt32();
+ if (_aidl_parcelable_raw_size < 0) return ::android::BAD_VALUE;
+ [[maybe_unused]] size_t _aidl_parcelable_size = static_cast<size_t>(_aidl_parcelable_raw_size);
+ if (_aidl_start_pos > SIZE_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE;
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&boolArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&charArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&floatArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&stringArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&boolMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&charMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&floatMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&stringMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+}
+::android::status_t FixedSizeArrayExample::writeToParcel(::android::Parcel* _aidl_parcel) const {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ auto _aidl_start_pos = _aidl_parcel->dataPosition();
+ _aidl_parcel->writeInt32(0);
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(boolArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(charArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(floatArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(stringArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(boolMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(charMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(floatMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(stringMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableArray);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableMatrix);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ auto _aidl_end_pos = _aidl_parcel->dataPosition();
+ _aidl_parcel->setDataPosition(_aidl_start_pos);
+ _aidl_parcel->writeInt32(_aidl_end_pos - _aidl_start_pos);
+ _aidl_parcel->setDataPosition(_aidl_end_pos);
+ return _aidl_ret_status;
+}
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, RepeatFixedSizeArray, "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray")
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <binder/Parcel.h>
+#include <android-base/macros.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+
+FixedSizeArrayExample::BpRepeatFixedSizeArray::BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl)
+ : BpInterface<IRepeatFixedSizeArray>(_aidl_impl){
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBytes(const std::array<uint8_t, 3>& input, std::array<uint8_t, 3>* repeated, std::array<uint8_t, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBytes(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatInts(const std::array<int32_t, 3>& input, std::array<int32_t, 3>* repeated, std::array<int32_t, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatInts, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->RepeatInts(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBinders(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->RepeatParcelables(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& input, std::array<std::array<uint8_t, 2>, 3>* repeated, std::array<std::array<uint8_t, 2>, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBytes(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& input, std::array<std::array<int32_t, 2>, 3>* repeated, std::array<std::array<int32_t, 2>, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dInts(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBinders(const std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>& input, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* repeated, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBinders(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dParcelables(const std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>& input, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* repeated, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* _aidl_return) {
+ ::android::Parcel _aidl_data;
+ _aidl_data.markForBinder(remoteStrong());
+ ::android::Parcel _aidl_reply;
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ ::android::binder::Status _aidl_status;
+ _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_data.writeFixedArray(input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables, _aidl_data, &_aidl_reply, 0);
+ if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl())) {
+ return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dParcelables(input, repeated, _aidl_return);
+ }
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ if (!_aidl_status.isOk()) {
+ return _aidl_status;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_ret_status = _aidl_reply.readFixedArray(repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ goto _aidl_error;
+ }
+ _aidl_error:
+ _aidl_status.setFromStatusT(_aidl_ret_status);
+ return _aidl_status;
+}
+
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <binder/Parcel.h>
+#include <binder/Stability.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+
+FixedSizeArrayExample::BnRepeatFixedSizeArray::BnRepeatFixedSizeArray()
+{
+ ::android::internal::Stability::markCompilationUnit(this);
+}
+
+::android::status_t FixedSizeArrayExample::BnRepeatFixedSizeArray::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ switch (_aidl_code) {
+ case BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes:
+ {
+ std::array<uint8_t, 3> in_input;
+ std::array<uint8_t, 3> out_repeated;
+ std::array<uint8_t, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(RepeatBytes(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_RepeatInts:
+ {
+ std::array<int32_t, 3> in_input;
+ std::array<int32_t, 3> out_repeated;
+ std::array<int32_t, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(RepeatInts(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders:
+ {
+ std::array<::android::sp<::android::IBinder>, 3> in_input;
+ std::array<::android::sp<::android::IBinder>, 3> out_repeated;
+ std::array<::android::sp<::android::IBinder>, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(RepeatBinders(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables:
+ {
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> in_input;
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> out_repeated;
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(RepeatParcelables(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes:
+ {
+ std::array<std::array<uint8_t, 2>, 3> in_input;
+ std::array<std::array<uint8_t, 2>, 3> out_repeated;
+ std::array<std::array<uint8_t, 2>, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(Repeat2dBytes(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts:
+ {
+ std::array<std::array<int32_t, 2>, 3> in_input;
+ std::array<std::array<int32_t, 2>, 3> out_repeated;
+ std::array<std::array<int32_t, 2>, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(Repeat2dInts(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders:
+ {
+ std::array<std::array<::android::sp<::android::IBinder>, 2>, 3> in_input;
+ std::array<std::array<::android::sp<::android::IBinder>, 2>, 3> out_repeated;
+ std::array<std::array<::android::sp<::android::IBinder>, 2>, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(Repeat2dBinders(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables:
+ {
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3> in_input;
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3> out_repeated;
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3> _aidl_return;
+ if (!(_aidl_data.checkInterface(this))) {
+ _aidl_ret_status = ::android::BAD_TYPE;
+ break;
+ }
+ _aidl_ret_status = _aidl_data.readFixedArray(&in_input);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ ::android::binder::Status _aidl_status(Repeat2dParcelables(in_input, &out_repeated, &_aidl_return));
+ _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ if (!_aidl_status.isOk()) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ break;
+ }
+ }
+ break;
+ default:
+ {
+ _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
+ }
+ break;
+ }
+ if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
+ _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
+ }
+ return _aidl_ret_status;
+}
+
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+::android::status_t FixedSizeArrayExample::IntParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ [[maybe_unused]] size_t _aidl_start_pos = _aidl_parcel->dataPosition();
+ int32_t _aidl_parcelable_raw_size = _aidl_parcel->readInt32();
+ if (_aidl_parcelable_raw_size < 0) return ::android::BAD_VALUE;
+ [[maybe_unused]] size_t _aidl_parcelable_size = static_cast<size_t>(_aidl_parcelable_raw_size);
+ if (_aidl_start_pos > SIZE_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE;
+ if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+ }
+ _aidl_ret_status = _aidl_parcel->readInt32(&value);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
+ return _aidl_ret_status;
+}
+::android::status_t FixedSizeArrayExample::IntParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ auto _aidl_start_pos = _aidl_parcel->dataPosition();
+ _aidl_parcel->writeInt32(0);
+ _aidl_ret_status = _aidl_parcel->writeInt32(value);
+ if (((_aidl_ret_status) != (::android::OK))) {
+ return _aidl_ret_status;
+ }
+ auto _aidl_end_pos = _aidl_parcel->dataPosition();
+ _aidl_parcel->setDataPosition(_aidl_start_pos);
+ _aidl_parcel->writeInt32(_aidl_end_pos - _aidl_start_pos);
+ _aidl_parcel->setDataPosition(_aidl_end_pos);
+ return _aidl_ret_status;
+}
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, EmptyInterface, "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface")
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <binder/Parcel.h>
+#include <android-base/macros.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+
+FixedSizeArrayExample::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl)
+ : BpInterface<IEmptyInterface>(_aidl_impl){
+}
+
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <binder/Parcel.h>
+#include <binder/Stability.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+
+FixedSizeArrayExample::BnEmptyInterface::BnEmptyInterface()
+{
+ ::android::internal::Stability::markCompilationUnit(this);
+}
+
+::android::status_t FixedSizeArrayExample::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
+ ::android::status_t _aidl_ret_status = ::android::OK;
+ switch (_aidl_code) {
+ default:
+ {
+ _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
+ }
+ break;
+ }
+ if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
+ _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
+ }
+ return _aidl_ret_status;
+}
+
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d
new file mode 100644
index 0000000..940e183
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d
@@ -0,0 +1,2 @@
+out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp : \
+ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h
new file mode 100644
index 0000000..ce72aa3
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h
@@ -0,0 +1 @@
+#error TODO(b/111362593) parcelables do not have bn classes
\ No newline at end of file
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h
new file mode 100644
index 0000000..27af6b1
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h
@@ -0,0 +1 @@
+#error TODO(b/111362593) parcelables do not have bp classes
\ No newline at end of file
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/FixedSizeArrayExample.h b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/FixedSizeArrayExample.h
new file mode 100644
index 0000000..5262386
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/FixedSizeArrayExample.h
@@ -0,0 +1,416 @@
+#pragma once
+
+#include <android/aidl/fixedsizearray/FixedSizeArrayExample.h>
+#include <android/binder_to_string.h>
+#include <array>
+#include <binder/Enums.h>
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <binder/ParcelFileDescriptor.h>
+#include <binder/Status.h>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+class FixedSizeArrayExample : public ::android::Parcelable {
+public:
+ class IntParcelable : public ::android::Parcelable {
+ public:
+ int32_t value = 0;
+ inline bool operator!=(const IntParcelable& rhs) const {
+ return std::tie(value) != std::tie(rhs.value);
+ }
+ inline bool operator<(const IntParcelable& rhs) const {
+ return std::tie(value) < std::tie(rhs.value);
+ }
+ inline bool operator<=(const IntParcelable& rhs) const {
+ return std::tie(value) <= std::tie(rhs.value);
+ }
+ inline bool operator==(const IntParcelable& rhs) const {
+ return std::tie(value) == std::tie(rhs.value);
+ }
+ inline bool operator>(const IntParcelable& rhs) const {
+ return std::tie(value) > std::tie(rhs.value);
+ }
+ inline bool operator>=(const IntParcelable& rhs) const {
+ return std::tie(value) >= std::tie(rhs.value);
+ }
+
+ ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final;
+ ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final;
+ static const ::android::String16& getParcelableDescriptor() {
+ static const ::android::StaticString16 DESCIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable");
+ return DESCIPTOR;
+ }
+ inline std::string toString() const {
+ std::ostringstream os;
+ os << "IntParcelable{";
+ os << "value: " << ::android::internal::ToString(value);
+ os << "}";
+ return os.str();
+ }
+ }; // class IntParcelable
+ class IRepeatFixedSizeArray : public ::android::IInterface {
+ public:
+ DECLARE_META_INTERFACE(RepeatFixedSizeArray)
+ virtual ::android::binder::Status RepeatBytes(const std::array<uint8_t, 3>& input, std::array<uint8_t, 3>* repeated, std::array<uint8_t, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status RepeatInts(const std::array<int32_t, 3>& input, std::array<int32_t, 3>* repeated, std::array<int32_t, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& input, std::array<std::array<uint8_t, 2>, 3>* repeated, std::array<std::array<uint8_t, 2>, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& input, std::array<std::array<int32_t, 2>, 3>* repeated, std::array<std::array<int32_t, 2>, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status Repeat2dBinders(const std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>& input, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* repeated, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* _aidl_return) = 0;
+ virtual ::android::binder::Status Repeat2dParcelables(const std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>& input, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* repeated, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* _aidl_return) = 0;
+ }; // class IRepeatFixedSizeArray
+
+ class IRepeatFixedSizeArrayDefault : public IRepeatFixedSizeArray {
+ public:
+ ::android::IBinder* onAsBinder() override {
+ return nullptr;
+ }
+ ::android::binder::Status RepeatBytes(const std::array<uint8_t, 3>& /*input*/, std::array<uint8_t, 3>* /*repeated*/, std::array<uint8_t, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status RepeatInts(const std::array<int32_t, 3>& /*input*/, std::array<int32_t, 3>* /*repeated*/, std::array<int32_t, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& /*input*/, std::array<::android::sp<::android::IBinder>, 3>* /*repeated*/, std::array<::android::sp<::android::IBinder>, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& /*input*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*repeated*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& /*input*/, std::array<std::array<uint8_t, 2>, 3>* /*repeated*/, std::array<std::array<uint8_t, 2>, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& /*input*/, std::array<std::array<int32_t, 2>, 3>* /*repeated*/, std::array<std::array<int32_t, 2>, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status Repeat2dBinders(const std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>& /*input*/, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* /*repeated*/, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ ::android::binder::Status Repeat2dParcelables(const std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>& /*input*/, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* /*repeated*/, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* /*_aidl_return*/) override {
+ return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
+ }
+ }; // class IRepeatFixedSizeArrayDefault
+ class BpRepeatFixedSizeArray : public ::android::BpInterface<IRepeatFixedSizeArray> {
+ public:
+ explicit BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl);
+ virtual ~BpRepeatFixedSizeArray() = default;
+ ::android::binder::Status RepeatBytes(const std::array<uint8_t, 3>& input, std::array<uint8_t, 3>* repeated, std::array<uint8_t, 3>* _aidl_return) override;
+ ::android::binder::Status RepeatInts(const std::array<int32_t, 3>& input, std::array<int32_t, 3>* repeated, std::array<int32_t, 3>* _aidl_return) override;
+ ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override;
+ ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override;
+ ::android::binder::Status Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& input, std::array<std::array<uint8_t, 2>, 3>* repeated, std::array<std::array<uint8_t, 2>, 3>* _aidl_return) override;
+ ::android::binder::Status Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& input, std::array<std::array<int32_t, 2>, 3>* repeated, std::array<std::array<int32_t, 2>, 3>* _aidl_return) override;
+ ::android::binder::Status Repeat2dBinders(const std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>& input, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* repeated, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* _aidl_return) override;
+ ::android::binder::Status Repeat2dParcelables(const std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>& input, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* repeated, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* _aidl_return) override;
+ }; // class BpRepeatFixedSizeArray
+ class BnRepeatFixedSizeArray : public ::android::BnInterface<IRepeatFixedSizeArray> {
+ public:
+ static constexpr uint32_t TRANSACTION_RepeatBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 0;
+ static constexpr uint32_t TRANSACTION_RepeatInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 1;
+ static constexpr uint32_t TRANSACTION_RepeatBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 2;
+ static constexpr uint32_t TRANSACTION_RepeatParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 3;
+ static constexpr uint32_t TRANSACTION_Repeat2dBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 4;
+ static constexpr uint32_t TRANSACTION_Repeat2dInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 5;
+ static constexpr uint32_t TRANSACTION_Repeat2dBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 6;
+ static constexpr uint32_t TRANSACTION_Repeat2dParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 7;
+ explicit BnRepeatFixedSizeArray();
+ ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override;
+ }; // class BnRepeatFixedSizeArray
+
+ class IRepeatFixedSizeArrayDelegator : public BnRepeatFixedSizeArray {
+ public:
+ explicit IRepeatFixedSizeArrayDelegator(::android::sp<IRepeatFixedSizeArray> &impl) : _aidl_delegate(impl) {}
+
+ ::android::binder::Status RepeatBytes(const std::array<uint8_t, 3>& input, std::array<uint8_t, 3>* repeated, std::array<uint8_t, 3>* _aidl_return) override {
+ return _aidl_delegate->RepeatBytes(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status RepeatInts(const std::array<int32_t, 3>& input, std::array<int32_t, 3>* repeated, std::array<int32_t, 3>* _aidl_return) override {
+ return _aidl_delegate->RepeatInts(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override {
+ return _aidl_delegate->RepeatBinders(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override {
+ return _aidl_delegate->RepeatParcelables(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status Repeat2dBytes(const std::array<std::array<uint8_t, 2>, 3>& input, std::array<std::array<uint8_t, 2>, 3>* repeated, std::array<std::array<uint8_t, 2>, 3>* _aidl_return) override {
+ return _aidl_delegate->Repeat2dBytes(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status Repeat2dInts(const std::array<std::array<int32_t, 2>, 3>& input, std::array<std::array<int32_t, 2>, 3>* repeated, std::array<std::array<int32_t, 2>, 3>* _aidl_return) override {
+ return _aidl_delegate->Repeat2dInts(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status Repeat2dBinders(const std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>& input, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* repeated, std::array<std::array<::android::sp<::android::IBinder>, 2>, 3>* _aidl_return) override {
+ return _aidl_delegate->Repeat2dBinders(input, repeated, _aidl_return);
+ }
+ ::android::binder::Status Repeat2dParcelables(const std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>& input, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* repeated, std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 3>* _aidl_return) override {
+ return _aidl_delegate->Repeat2dParcelables(input, repeated, _aidl_return);
+ }
+ private:
+ ::android::sp<IRepeatFixedSizeArray> _aidl_delegate;
+ }; // class IRepeatFixedSizeArrayDelegator
+ enum class ByteEnum : int8_t {
+ A = 0,
+ };
+ enum class IntEnum : int32_t {
+ A = 0,
+ };
+ enum class LongEnum : int64_t {
+ A = 0L,
+ };
+ class IEmptyInterface : public ::android::IInterface {
+ public:
+ DECLARE_META_INTERFACE(EmptyInterface)
+ }; // class IEmptyInterface
+
+ class IEmptyInterfaceDefault : public IEmptyInterface {
+ public:
+ ::android::IBinder* onAsBinder() override {
+ return nullptr;
+ }
+ }; // class IEmptyInterfaceDefault
+ class BpEmptyInterface : public ::android::BpInterface<IEmptyInterface> {
+ public:
+ explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl);
+ virtual ~BpEmptyInterface() = default;
+ }; // class BpEmptyInterface
+ class BnEmptyInterface : public ::android::BnInterface<IEmptyInterface> {
+ public:
+ explicit BnEmptyInterface();
+ ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override;
+ }; // class BnEmptyInterface
+
+ class IEmptyInterfaceDelegator : public BnEmptyInterface {
+ public:
+ explicit IEmptyInterfaceDelegator(::android::sp<IEmptyInterface> &impl) : _aidl_delegate(impl) {}
+
+ private:
+ ::android::sp<IEmptyInterface> _aidl_delegate;
+ }; // class IEmptyInterfaceDelegator
+ std::array<bool, 2> boolArray = {};
+ std::array<uint8_t, 2> byteArray = {};
+ std::array<char16_t, 2> charArray = {};
+ std::array<int32_t, 2> intArray = {};
+ std::array<int64_t, 2> longArray = {};
+ std::array<float, 2> floatArray = {};
+ std::array<double, 2> doubleArray = {};
+ std::array<::std::string, 2> stringArray = {};
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2> byteEnumArray = {};
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2> intEnumArray = {};
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2> longEnumArray = {};
+ std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2> parcelableArray = {};
+ std::array<std::array<bool, 2>, 2> boolMatrix = {};
+ std::array<std::array<uint8_t, 2>, 2> byteMatrix = {};
+ std::array<std::array<char16_t, 2>, 2> charMatrix = {};
+ std::array<std::array<int32_t, 2>, 2> intMatrix = {};
+ std::array<std::array<int64_t, 2>, 2> longMatrix = {};
+ std::array<std::array<float, 2>, 2> floatMatrix = {};
+ std::array<std::array<double, 2>, 2> doubleMatrix = {};
+ std::array<std::array<::std::string, 2>, 2> stringMatrix = {};
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2>, 2> byteEnumMatrix = {};
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2>, 2> intEnumMatrix = {};
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2>, 2> longEnumMatrix = {};
+ std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2>, 2> parcelableMatrix = {};
+ ::std::optional<std::array<bool, 2>> boolNullableArray;
+ ::std::optional<std::array<uint8_t, 2>> byteNullableArray;
+ ::std::optional<std::array<char16_t, 2>> charNullableArray;
+ ::std::optional<std::array<int32_t, 2>> intNullableArray;
+ ::std::optional<std::array<int64_t, 2>> longNullableArray;
+ ::std::optional<std::array<float, 2>> floatNullableArray;
+ ::std::optional<std::array<double, 2>> doubleNullableArray;
+ ::std::optional<std::array<::std::optional<::std::string>, 2>> stringNullableArray;
+ ::std::optional<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2>> byteEnumNullableArray;
+ ::std::optional<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2>> intEnumNullableArray;
+ ::std::optional<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2>> longEnumNullableArray;
+ ::std::optional<std::array<::android::sp<::android::IBinder>, 2>> binderNullableArray;
+ ::std::optional<std::array<::std::optional<::android::os::ParcelFileDescriptor>, 2>> pfdNullableArray;
+ ::std::optional<std::array<::std::optional<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable>, 2>> parcelableNullableArray;
+ ::std::optional<std::array<::android::sp<::android::aidl::fixedsizearray::FixedSizeArrayExample::IEmptyInterface>, 2>> interfaceNullableArray;
+ ::std::optional<std::array<std::array<bool, 2>, 2>> boolNullableMatrix;
+ ::std::optional<std::array<std::array<uint8_t, 2>, 2>> byteNullableMatrix;
+ ::std::optional<std::array<std::array<char16_t, 2>, 2>> charNullableMatrix;
+ ::std::optional<std::array<std::array<int32_t, 2>, 2>> intNullableMatrix;
+ ::std::optional<std::array<std::array<int64_t, 2>, 2>> longNullableMatrix;
+ ::std::optional<std::array<std::array<float, 2>, 2>> floatNullableMatrix;
+ ::std::optional<std::array<std::array<double, 2>, 2>> doubleNullableMatrix;
+ ::std::optional<std::array<std::array<::std::optional<::std::string>, 2>, 2>> stringNullableMatrix;
+ ::std::optional<std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2>, 2>> byteEnumNullableMatrix;
+ ::std::optional<std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2>, 2>> intEnumNullableMatrix;
+ ::std::optional<std::array<std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2>, 2>> longEnumNullableMatrix;
+ ::std::optional<std::array<std::array<::android::sp<::android::IBinder>, 2>, 2>> binderNullableMatrix;
+ ::std::optional<std::array<std::array<::std::optional<::android::os::ParcelFileDescriptor>, 2>, 2>> pfdNullableMatrix;
+ ::std::optional<std::array<std::array<::std::optional<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable>, 2>, 2>> parcelableNullableMatrix;
+ ::std::optional<std::array<std::array<::android::sp<::android::aidl::fixedsizearray::FixedSizeArrayExample::IEmptyInterface>, 2>, 2>> interfaceNullableMatrix;
+ inline bool operator!=(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) != std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+ inline bool operator<(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) < std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+ inline bool operator<=(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) <= std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+ inline bool operator==(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) == std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+ inline bool operator>(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) > std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+ inline bool operator>=(const FixedSizeArrayExample& rhs) const {
+ return std::tie(boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) >= std::tie(rhs.boolArray, rhs.byteArray, rhs.charArray, rhs.intArray, rhs.longArray, rhs.floatArray, rhs.doubleArray, rhs.stringArray, rhs.byteEnumArray, rhs.intEnumArray, rhs.longEnumArray, rhs.parcelableArray, rhs.boolMatrix, rhs.byteMatrix, rhs.charMatrix, rhs.intMatrix, rhs.longMatrix, rhs.floatMatrix, rhs.doubleMatrix, rhs.stringMatrix, rhs.byteEnumMatrix, rhs.intEnumMatrix, rhs.longEnumMatrix, rhs.parcelableMatrix, rhs.boolNullableArray, rhs.byteNullableArray, rhs.charNullableArray, rhs.intNullableArray, rhs.longNullableArray, rhs.floatNullableArray, rhs.doubleNullableArray, rhs.stringNullableArray, rhs.byteEnumNullableArray, rhs.intEnumNullableArray, rhs.longEnumNullableArray, rhs.binderNullableArray, rhs.pfdNullableArray, rhs.parcelableNullableArray, rhs.interfaceNullableArray, rhs.boolNullableMatrix, rhs.byteNullableMatrix, rhs.charNullableMatrix, rhs.intNullableMatrix, rhs.longNullableMatrix, rhs.floatNullableMatrix, rhs.doubleNullableMatrix, rhs.stringNullableMatrix, rhs.byteEnumNullableMatrix, rhs.intEnumNullableMatrix, rhs.longEnumNullableMatrix, rhs.binderNullableMatrix, rhs.pfdNullableMatrix, rhs.parcelableNullableMatrix, rhs.interfaceNullableMatrix);
+ }
+
+ ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final;
+ ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final;
+ static const ::android::String16& getParcelableDescriptor() {
+ static const ::android::StaticString16 DESCIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample");
+ return DESCIPTOR;
+ }
+ inline std::string toString() const {
+ std::ostringstream os;
+ os << "FixedSizeArrayExample{";
+ os << "boolArray: " << ::android::internal::ToString(boolArray);
+ os << ", byteArray: " << ::android::internal::ToString(byteArray);
+ os << ", charArray: " << ::android::internal::ToString(charArray);
+ os << ", intArray: " << ::android::internal::ToString(intArray);
+ os << ", longArray: " << ::android::internal::ToString(longArray);
+ os << ", floatArray: " << ::android::internal::ToString(floatArray);
+ os << ", doubleArray: " << ::android::internal::ToString(doubleArray);
+ os << ", stringArray: " << ::android::internal::ToString(stringArray);
+ os << ", byteEnumArray: " << ::android::internal::ToString(byteEnumArray);
+ os << ", intEnumArray: " << ::android::internal::ToString(intEnumArray);
+ os << ", longEnumArray: " << ::android::internal::ToString(longEnumArray);
+ os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray);
+ os << ", boolMatrix: " << ::android::internal::ToString(boolMatrix);
+ os << ", byteMatrix: " << ::android::internal::ToString(byteMatrix);
+ os << ", charMatrix: " << ::android::internal::ToString(charMatrix);
+ os << ", intMatrix: " << ::android::internal::ToString(intMatrix);
+ os << ", longMatrix: " << ::android::internal::ToString(longMatrix);
+ os << ", floatMatrix: " << ::android::internal::ToString(floatMatrix);
+ os << ", doubleMatrix: " << ::android::internal::ToString(doubleMatrix);
+ os << ", stringMatrix: " << ::android::internal::ToString(stringMatrix);
+ os << ", byteEnumMatrix: " << ::android::internal::ToString(byteEnumMatrix);
+ os << ", intEnumMatrix: " << ::android::internal::ToString(intEnumMatrix);
+ os << ", longEnumMatrix: " << ::android::internal::ToString(longEnumMatrix);
+ os << ", parcelableMatrix: " << ::android::internal::ToString(parcelableMatrix);
+ os << ", boolNullableArray: " << ::android::internal::ToString(boolNullableArray);
+ os << ", byteNullableArray: " << ::android::internal::ToString(byteNullableArray);
+ os << ", charNullableArray: " << ::android::internal::ToString(charNullableArray);
+ os << ", intNullableArray: " << ::android::internal::ToString(intNullableArray);
+ os << ", longNullableArray: " << ::android::internal::ToString(longNullableArray);
+ os << ", floatNullableArray: " << ::android::internal::ToString(floatNullableArray);
+ os << ", doubleNullableArray: " << ::android::internal::ToString(doubleNullableArray);
+ os << ", stringNullableArray: " << ::android::internal::ToString(stringNullableArray);
+ os << ", byteEnumNullableArray: " << ::android::internal::ToString(byteEnumNullableArray);
+ os << ", intEnumNullableArray: " << ::android::internal::ToString(intEnumNullableArray);
+ os << ", longEnumNullableArray: " << ::android::internal::ToString(longEnumNullableArray);
+ os << ", binderNullableArray: " << ::android::internal::ToString(binderNullableArray);
+ os << ", pfdNullableArray: " << ::android::internal::ToString(pfdNullableArray);
+ os << ", parcelableNullableArray: " << ::android::internal::ToString(parcelableNullableArray);
+ os << ", interfaceNullableArray: " << ::android::internal::ToString(interfaceNullableArray);
+ os << ", boolNullableMatrix: " << ::android::internal::ToString(boolNullableMatrix);
+ os << ", byteNullableMatrix: " << ::android::internal::ToString(byteNullableMatrix);
+ os << ", charNullableMatrix: " << ::android::internal::ToString(charNullableMatrix);
+ os << ", intNullableMatrix: " << ::android::internal::ToString(intNullableMatrix);
+ os << ", longNullableMatrix: " << ::android::internal::ToString(longNullableMatrix);
+ os << ", floatNullableMatrix: " << ::android::internal::ToString(floatNullableMatrix);
+ os << ", doubleNullableMatrix: " << ::android::internal::ToString(doubleNullableMatrix);
+ os << ", stringNullableMatrix: " << ::android::internal::ToString(stringNullableMatrix);
+ os << ", byteEnumNullableMatrix: " << ::android::internal::ToString(byteEnumNullableMatrix);
+ os << ", intEnumNullableMatrix: " << ::android::internal::ToString(intEnumNullableMatrix);
+ os << ", longEnumNullableMatrix: " << ::android::internal::ToString(longEnumNullableMatrix);
+ os << ", binderNullableMatrix: " << ::android::internal::ToString(binderNullableMatrix);
+ os << ", pfdNullableMatrix: " << ::android::internal::ToString(pfdNullableMatrix);
+ os << ", parcelableNullableMatrix: " << ::android::internal::ToString(parcelableNullableMatrix);
+ os << ", interfaceNullableMatrix: " << ::android::internal::ToString(interfaceNullableMatrix);
+ os << "}";
+ return os.str();
+ }
+}; // class FixedSizeArrayExample
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+[[nodiscard]] static inline std::string toString(FixedSizeArrayExample::ByteEnum val) {
+ switch(val) {
+ case FixedSizeArrayExample::ByteEnum::A:
+ return "A";
+ default:
+ return std::to_string(static_cast<int8_t>(val));
+ }
+}
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+namespace android {
+namespace internal {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++17-extensions"
+template <>
+constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum> = {
+ ::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum::A,
+};
+#pragma clang diagnostic pop
+} // namespace internal
+} // namespace android
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+[[nodiscard]] static inline std::string toString(FixedSizeArrayExample::IntEnum val) {
+ switch(val) {
+ case FixedSizeArrayExample::IntEnum::A:
+ return "A";
+ default:
+ return std::to_string(static_cast<int32_t>(val));
+ }
+}
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+namespace android {
+namespace internal {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++17-extensions"
+template <>
+constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum> = {
+ ::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum::A,
+};
+#pragma clang diagnostic pop
+} // namespace internal
+} // namespace android
+namespace android {
+namespace aidl {
+namespace fixedsizearray {
+[[nodiscard]] static inline std::string toString(FixedSizeArrayExample::LongEnum val) {
+ switch(val) {
+ case FixedSizeArrayExample::LongEnum::A:
+ return "A";
+ default:
+ return std::to_string(static_cast<int64_t>(val));
+ }
+}
+} // namespace fixedsizearray
+} // namespace aidl
+} // namespace android
+namespace android {
+namespace internal {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++17-extensions"
+template <>
+constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum> = {
+ ::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum::A,
+};
+#pragma clang diagnostic pop
+} // namespace internal
+} // namespace android
diff --git a/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/timestamp b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/timestamp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/timestamp
diff --git a/tests/golden_test.sh b/tests/golden_test.sh
index e6de268..c000e84 100755
--- a/tests/golden_test.sh
+++ b/tests/golden_test.sh
@@ -46,6 +46,7 @@
"aidl_test_loggable_interface-java-source"
"aidl_test_loggable_interface-ndk-source"
"aidl-test-interface-platform-java-source"
+ "aidl-test-fixedsizearray-cpp-source"
"aidl-test-fixedsizearray-ndk-source"
)
