diff --git a/cpp/test/generated/binary/protocols.cc b/cpp/test/generated/binary/protocols.cc index 5fc3efc9..61bec10c 100644 --- a/cpp/test/generated/binary/protocols.cc +++ b/cpp/test/generated/binary/protocols.cc @@ -4139,6 +4139,26 @@ void EnumsWriter::WriteRecImpl(test_model::RecordWithEnums const& value) { test_model::binary::WriteRecordWithEnums(stream_, value); } +void EnumsWriter::WriteRecArrayImpl(yardl::DynamicNDArray const& value) { + yardl::binary::WriteDynamicNDArray(stream_, value); +} + +void EnumsWriter::WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::binary::WriteDynamicNDArray(stream_, value); +} + +void EnumsWriter::WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::binary::WriteDynamicNDArray(stream_, value); +} + +void EnumsWriter::WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) { + yardl::binary::WriteDynamicNDArray(stream_, value); +} + +void EnumsWriter::WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::binary::WriteDynamicNDArray(stream_, value); +} + void EnumsWriter::Flush() { stream_.Flush(); } @@ -4163,6 +4183,26 @@ void EnumsReader::ReadRecImpl(test_model::RecordWithEnums& value) { test_model::binary::ReadRecordWithEnums(stream_, value); } +void EnumsReader::ReadRecArrayImpl(yardl::DynamicNDArray& value) { + yardl::binary::ReadDynamicNDArray(stream_, value); +} + +void EnumsReader::ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) { + yardl::binary::ReadDynamicNDArray(stream_, value); +} + +void EnumsReader::ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) { + yardl::binary::ReadDynamicNDArray(stream_, value); +} + +void EnumsReader::ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) { + yardl::binary::ReadDynamicNDArray(stream_, value); +} + +void EnumsReader::ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) { + yardl::binary::ReadDynamicNDArray(stream_, value); +} + void EnumsReader::CloseImpl() { if (!skip_completed_check_) { stream_.VerifyFinished(); diff --git a/cpp/test/generated/binary/protocols.h b/cpp/test/generated/binary/protocols.h index bac9ff8b..d0ad8366 100644 --- a/cpp/test/generated/binary/protocols.h +++ b/cpp/test/generated/binary/protocols.h @@ -1098,6 +1098,11 @@ class EnumsWriter : public test_model::EnumsWriterBase, yardl::binary::BinaryWri void WriteVecImpl(std::vector const& value) override; void WriteSizeImpl(test_model::SizeBasedEnum const& value) override; void WriteRecImpl(test_model::RecordWithEnums const& value) override; + void WriteRecArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) override; void CloseImpl() override; Version version_; @@ -1119,6 +1124,11 @@ class EnumsReader : public test_model::EnumsReaderBase, yardl::binary::BinaryRea void ReadVecImpl(std::vector& value) override; void ReadSizeImpl(test_model::SizeBasedEnum& value) override; void ReadRecImpl(test_model::RecordWithEnums& value) override; + void ReadRecArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) override; void CloseImpl() override; Version version_; diff --git a/cpp/test/generated/hdf5/protocols.cc b/cpp/test/generated/hdf5/protocols.cc index 58d2006d..79b77501 100644 --- a/cpp/test/generated/hdf5/protocols.cc +++ b/cpp/test/generated/hdf5/protocols.cc @@ -3304,6 +3304,26 @@ void EnumsWriter::WriteRecImpl(test_model::RecordWithEnums const& value) { yardl::hdf5::WriteScalarDataset(group_, "rec", test_model::hdf5::GetRecordWithEnumsHdf5Ddl(), value); } +void EnumsWriter::WriteRecArrayImpl(yardl::DynamicNDArray const& value) { + yardl::hdf5::WriteScalarDataset, yardl::DynamicNDArray>(group_, "recArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithEnumsHdf5Ddl()), value); +} + +void EnumsWriter::WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::hdf5::WriteScalarDataset, yardl::DynamicNDArray>(group_, "recWithFixedVectorsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithFixedVectorsHdf5Ddl()), value); +} + +void EnumsWriter::WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::hdf5::WriteScalarDataset, yardl::DynamicNDArray>(group_, "recWithOptionalFieldsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithOptionalFieldsHdf5Ddl()), value); +} + +void EnumsWriter::WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) { + yardl::hdf5::WriteScalarDataset, yardl::DynamicNDArray>(group_, "recWithVlensArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithVlensHdf5Ddl()), value); +} + +void EnumsWriter::WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) { + yardl::hdf5::WriteScalarDataset, yardl::DynamicNDArray>(group_, "recWithStringsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithStringsHdf5Ddl()), value); +} + EnumsReader::EnumsReader(std::string path, bool skip_completed_check) : test_model::EnumsReaderBase(skip_completed_check), yardl::hdf5::Hdf5Reader::Hdf5Reader(path, "Enums", schema_) { } @@ -3324,6 +3344,26 @@ void EnumsReader::ReadRecImpl(test_model::RecordWithEnums& value) { yardl::hdf5::ReadScalarDataset(group_, "rec", test_model::hdf5::GetRecordWithEnumsHdf5Ddl(), value); } +void EnumsReader::ReadRecArrayImpl(yardl::DynamicNDArray& value) { + yardl::hdf5::ReadScalarDataset, yardl::DynamicNDArray>(group_, "recArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithEnumsHdf5Ddl()), value); +} + +void EnumsReader::ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) { + yardl::hdf5::ReadScalarDataset, yardl::DynamicNDArray>(group_, "recWithFixedVectorsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithFixedVectorsHdf5Ddl()), value); +} + +void EnumsReader::ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) { + yardl::hdf5::ReadScalarDataset, yardl::DynamicNDArray>(group_, "recWithOptionalFieldsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithOptionalFieldsHdf5Ddl()), value); +} + +void EnumsReader::ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) { + yardl::hdf5::ReadScalarDataset, yardl::DynamicNDArray>(group_, "recWithVlensArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithVlensHdf5Ddl()), value); +} + +void EnumsReader::ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) { + yardl::hdf5::ReadScalarDataset, yardl::DynamicNDArray>(group_, "recWithStringsArray", yardl::hdf5::DynamicNDArrayDdl(test_model::hdf5::GetRecordWithStringsHdf5Ddl()), value); +} + FlagsWriter::FlagsWriter(std::string path) : yardl::hdf5::Hdf5Writer::Hdf5Writer(path, "Flags", schema_) { } diff --git a/cpp/test/generated/hdf5/protocols.h b/cpp/test/generated/hdf5/protocols.h index 58658ea9..385cddb2 100644 --- a/cpp/test/generated/hdf5/protocols.h +++ b/cpp/test/generated/hdf5/protocols.h @@ -856,6 +856,16 @@ class EnumsWriter : public test_model::EnumsWriterBase, public yardl::hdf5::Hdf5 void WriteRecImpl(test_model::RecordWithEnums const& value) override; + void WriteRecArrayImpl(yardl::DynamicNDArray const& value) override; + + void WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) override; + + void WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) override; + + void WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) override; + + void WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) override; + private: }; @@ -872,6 +882,16 @@ class EnumsReader : public test_model::EnumsReaderBase, public yardl::hdf5::Hdf5 void ReadRecImpl(test_model::RecordWithEnums& value) override; + void ReadRecArrayImpl(yardl::DynamicNDArray& value) override; + + void ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) override; + + void ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) override; + + void ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) override; + + void ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) override; + private: }; diff --git a/cpp/test/generated/mocks.cc b/cpp/test/generated/mocks.cc index 4bef75d9..870c8f13 100644 --- a/cpp/test/generated/mocks.cc +++ b/cpp/test/generated/mocks.cc @@ -3085,6 +3085,86 @@ class MockEnumsWriter : public EnumsWriterBase { WriteRecImpl_expected_values_.push(value); } + void WriteRecArrayImpl (yardl::DynamicNDArray const& value) override { + if (WriteRecArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Unexpected call to WriteRecArrayImpl"); + } + if (WriteRecArrayImpl_expected_values_.front() != value) { + throw std::runtime_error("Unexpected argument value for call to WriteRecArrayImpl"); + } + WriteRecArrayImpl_expected_values_.pop(); + } + + std::queue> WriteRecArrayImpl_expected_values_; + + void ExpectWriteRecArrayImpl (yardl::DynamicNDArray const& value) { + WriteRecArrayImpl_expected_values_.push(value); + } + + void WriteRecWithFixedVectorsArrayImpl (yardl::DynamicNDArray const& value) override { + if (WriteRecWithFixedVectorsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Unexpected call to WriteRecWithFixedVectorsArrayImpl"); + } + if (WriteRecWithFixedVectorsArrayImpl_expected_values_.front() != value) { + throw std::runtime_error("Unexpected argument value for call to WriteRecWithFixedVectorsArrayImpl"); + } + WriteRecWithFixedVectorsArrayImpl_expected_values_.pop(); + } + + std::queue> WriteRecWithFixedVectorsArrayImpl_expected_values_; + + void ExpectWriteRecWithFixedVectorsArrayImpl (yardl::DynamicNDArray const& value) { + WriteRecWithFixedVectorsArrayImpl_expected_values_.push(value); + } + + void WriteRecWithOptionalFieldsArrayImpl (yardl::DynamicNDArray const& value) override { + if (WriteRecWithOptionalFieldsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Unexpected call to WriteRecWithOptionalFieldsArrayImpl"); + } + if (WriteRecWithOptionalFieldsArrayImpl_expected_values_.front() != value) { + throw std::runtime_error("Unexpected argument value for call to WriteRecWithOptionalFieldsArrayImpl"); + } + WriteRecWithOptionalFieldsArrayImpl_expected_values_.pop(); + } + + std::queue> WriteRecWithOptionalFieldsArrayImpl_expected_values_; + + void ExpectWriteRecWithOptionalFieldsArrayImpl (yardl::DynamicNDArray const& value) { + WriteRecWithOptionalFieldsArrayImpl_expected_values_.push(value); + } + + void WriteRecWithVlensArrayImpl (yardl::DynamicNDArray const& value) override { + if (WriteRecWithVlensArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Unexpected call to WriteRecWithVlensArrayImpl"); + } + if (WriteRecWithVlensArrayImpl_expected_values_.front() != value) { + throw std::runtime_error("Unexpected argument value for call to WriteRecWithVlensArrayImpl"); + } + WriteRecWithVlensArrayImpl_expected_values_.pop(); + } + + std::queue> WriteRecWithVlensArrayImpl_expected_values_; + + void ExpectWriteRecWithVlensArrayImpl (yardl::DynamicNDArray const& value) { + WriteRecWithVlensArrayImpl_expected_values_.push(value); + } + + void WriteRecWithStringsArrayImpl (yardl::DynamicNDArray const& value) override { + if (WriteRecWithStringsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Unexpected call to WriteRecWithStringsArrayImpl"); + } + if (WriteRecWithStringsArrayImpl_expected_values_.front() != value) { + throw std::runtime_error("Unexpected argument value for call to WriteRecWithStringsArrayImpl"); + } + WriteRecWithStringsArrayImpl_expected_values_.pop(); + } + + std::queue> WriteRecWithStringsArrayImpl_expected_values_; + + void ExpectWriteRecWithStringsArrayImpl (yardl::DynamicNDArray const& value) { + WriteRecWithStringsArrayImpl_expected_values_.push(value); + } + void Verify() { if (!WriteSingleImpl_expected_values_.empty()) { throw std::runtime_error("Expected call to WriteSingleImpl was not received"); @@ -3098,6 +3178,21 @@ class MockEnumsWriter : public EnumsWriterBase { if (!WriteRecImpl_expected_values_.empty()) { throw std::runtime_error("Expected call to WriteRecImpl was not received"); } + if (!WriteRecArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Expected call to WriteRecArrayImpl was not received"); + } + if (!WriteRecWithFixedVectorsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Expected call to WriteRecWithFixedVectorsArrayImpl was not received"); + } + if (!WriteRecWithOptionalFieldsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Expected call to WriteRecWithOptionalFieldsArrayImpl was not received"); + } + if (!WriteRecWithVlensArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Expected call to WriteRecWithVlensArrayImpl was not received"); + } + if (!WriteRecWithStringsArrayImpl_expected_values_.empty()) { + throw std::runtime_error("Expected call to WriteRecWithStringsArrayImpl was not received"); + } } }; @@ -3133,6 +3228,31 @@ class TestEnumsWriterBase : public EnumsWriterBase { mock_writer_.ExpectWriteRecImpl(value); } + void WriteRecArrayImpl(yardl::DynamicNDArray const& value) override { + writer_->WriteRecArray(value); + mock_writer_.ExpectWriteRecArrayImpl(value); + } + + void WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) override { + writer_->WriteRecWithFixedVectorsArray(value); + mock_writer_.ExpectWriteRecWithFixedVectorsArrayImpl(value); + } + + void WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) override { + writer_->WriteRecWithOptionalFieldsArray(value); + mock_writer_.ExpectWriteRecWithOptionalFieldsArrayImpl(value); + } + + void WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) override { + writer_->WriteRecWithVlensArray(value); + mock_writer_.ExpectWriteRecWithVlensArrayImpl(value); + } + + void WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) override { + writer_->WriteRecWithStringsArray(value); + mock_writer_.ExpectWriteRecWithStringsArrayImpl(value); + } + void CloseImpl() override { close_called_ = true; writer_->Close(); diff --git a/cpp/test/generated/model.json b/cpp/test/generated/model.json index 53365d7a..4310f9f2 100644 --- a/cpp/test/generated/model.json +++ b/cpp/test/generated/model.json @@ -5229,6 +5229,46 @@ { "name": "rec", "type": "TestModel.RecordWithEnums" + }, + { + "name": "recArray", + "type": { + "array": { + "items": "TestModel.RecordWithEnums" + } + } + }, + { + "name": "recWithFixedVectorsArray", + "type": { + "array": { + "items": "TestModel.RecordWithFixedVectors" + } + } + }, + { + "name": "recWithOptionalFieldsArray", + "type": { + "array": { + "items": "TestModel.RecordWithOptionalFields" + } + } + }, + { + "name": "recWithVlensArray", + "type": { + "array": { + "items": "TestModel.RecordWithVlens" + } + } + }, + { + "name": "recWithStringsArray", + "type": { + "array": { + "items": "TestModel.RecordWithStrings" + } + } } ] }, diff --git a/cpp/test/generated/ndjson/protocols.cc b/cpp/test/generated/ndjson/protocols.cc index d37346a5..ea2dae10 100644 --- a/cpp/test/generated/ndjson/protocols.cc +++ b/cpp/test/generated/ndjson/protocols.cc @@ -3745,6 +3745,26 @@ void EnumsWriter::WriteRecImpl(test_model::RecordWithEnums const& value) { ordered_json json_value = value; yardl::ndjson::WriteProtocolValue(stream_, "rec", json_value);} +void EnumsWriter::WriteRecArrayImpl(yardl::DynamicNDArray const& value) { + ordered_json json_value = value; + yardl::ndjson::WriteProtocolValue(stream_, "recArray", json_value);} + +void EnumsWriter::WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) { + ordered_json json_value = value; + yardl::ndjson::WriteProtocolValue(stream_, "recWithFixedVectorsArray", json_value);} + +void EnumsWriter::WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) { + ordered_json json_value = value; + yardl::ndjson::WriteProtocolValue(stream_, "recWithOptionalFieldsArray", json_value);} + +void EnumsWriter::WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) { + ordered_json json_value = value; + yardl::ndjson::WriteProtocolValue(stream_, "recWithVlensArray", json_value);} + +void EnumsWriter::WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) { + ordered_json json_value = value; + yardl::ndjson::WriteProtocolValue(stream_, "recWithStringsArray", json_value);} + void EnumsWriter::Flush() { stream_.flush(); } @@ -3769,6 +3789,26 @@ void EnumsReader::ReadRecImpl(test_model::RecordWithEnums& value) { yardl::ndjson::ReadProtocolValue(stream_, line_, "rec", true, unused_step_, value); } +void EnumsReader::ReadRecArrayImpl(yardl::DynamicNDArray& value) { + yardl::ndjson::ReadProtocolValue(stream_, line_, "recArray", true, unused_step_, value); +} + +void EnumsReader::ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) { + yardl::ndjson::ReadProtocolValue(stream_, line_, "recWithFixedVectorsArray", true, unused_step_, value); +} + +void EnumsReader::ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) { + yardl::ndjson::ReadProtocolValue(stream_, line_, "recWithOptionalFieldsArray", true, unused_step_, value); +} + +void EnumsReader::ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) { + yardl::ndjson::ReadProtocolValue(stream_, line_, "recWithVlensArray", true, unused_step_, value); +} + +void EnumsReader::ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) { + yardl::ndjson::ReadProtocolValue(stream_, line_, "recWithStringsArray", true, unused_step_, value); +} + void EnumsReader::CloseImpl() { if (!skip_completed_check_) { VerifyFinished(); diff --git a/cpp/test/generated/ndjson/protocols.h b/cpp/test/generated/ndjson/protocols.h index 0bc2ad4b..b4f3e1bb 100644 --- a/cpp/test/generated/ndjson/protocols.h +++ b/cpp/test/generated/ndjson/protocols.h @@ -993,6 +993,11 @@ class EnumsWriter : public test_model::EnumsWriterBase, yardl::ndjson::NDJsonWri void WriteVecImpl(std::vector const& value) override; void WriteSizeImpl(test_model::SizeBasedEnum const& value) override; void WriteRecImpl(test_model::RecordWithEnums const& value) override; + void WriteRecArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) override; + void WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) override; void CloseImpl() override; }; @@ -1012,6 +1017,11 @@ class EnumsReader : public test_model::EnumsReaderBase, yardl::ndjson::NDJsonRea void ReadVecImpl(std::vector& value) override; void ReadSizeImpl(test_model::SizeBasedEnum& value) override; void ReadRecImpl(test_model::RecordWithEnums& value) override; + void ReadRecArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) override; + void ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) override; void CloseImpl() override; }; diff --git a/cpp/test/generated/protocols.cc b/cpp/test/generated/protocols.cc index 5c7f7622..16063286 100644 --- a/cpp/test/generated/protocols.cc +++ b/cpp/test/generated/protocols.cc @@ -4780,6 +4780,11 @@ void EnumsWriterBaseInvalidState(uint8_t attempted, [[maybe_unused]] bool end, u case 1: expected_method = "WriteVec()"; break; case 2: expected_method = "WriteSize()"; break; case 3: expected_method = "WriteRec()"; break; + case 4: expected_method = "WriteRecArray()"; break; + case 5: expected_method = "WriteRecWithFixedVectorsArray()"; break; + case 6: expected_method = "WriteRecWithOptionalFieldsArray()"; break; + case 7: expected_method = "WriteRecWithVlensArray()"; break; + case 8: expected_method = "WriteRecWithStringsArray()"; break; } std::string attempted_method; switch (attempted) { @@ -4787,7 +4792,12 @@ void EnumsWriterBaseInvalidState(uint8_t attempted, [[maybe_unused]] bool end, u case 1: attempted_method = "WriteVec()"; break; case 2: attempted_method = "WriteSize()"; break; case 3: attempted_method = "WriteRec()"; break; - case 4: attempted_method = "Close()"; break; + case 4: attempted_method = "WriteRecArray()"; break; + case 5: attempted_method = "WriteRecWithFixedVectorsArray()"; break; + case 6: attempted_method = "WriteRecWithOptionalFieldsArray()"; break; + case 7: attempted_method = "WriteRecWithVlensArray()"; break; + case 8: attempted_method = "WriteRecWithStringsArray()"; break; + case 9: attempted_method = "Close()"; break; } throw std::runtime_error("Expected call to " + expected_method + " but received call to " + attempted_method + " instead."); } @@ -4799,7 +4809,12 @@ void EnumsReaderBaseInvalidState(uint8_t attempted, uint8_t current) { case 1: return "ReadVec()"; case 2: return "ReadSize()"; case 3: return "ReadRec()"; - case 4: return "Close()"; + case 4: return "ReadRecArray()"; + case 5: return "ReadRecWithFixedVectorsArray()"; + case 6: return "ReadRecWithOptionalFieldsArray()"; + case 7: return "ReadRecWithVlensArray()"; + case 8: return "ReadRecWithStringsArray()"; + case 9: return "Close()"; default: return ""; } }; @@ -4808,7 +4823,7 @@ void EnumsReaderBaseInvalidState(uint8_t attempted, uint8_t current) { } // namespace -std::string EnumsWriterBase::schema_ = R"({"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]})"; +std::string EnumsWriterBase::schema_ = R"({"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"},{"name":"recArray","type":{"array":{"items":"TestModel.RecordWithEnums"}}},{"name":"recWithFixedVectorsArray","type":{"array":{"items":"TestModel.RecordWithFixedVectors"}}},{"name":"recWithOptionalFieldsArray","type":{"array":{"items":"TestModel.RecordWithOptionalFields"}}},{"name":"recWithVlensArray","type":{"array":{"items":"TestModel.RecordWithVlens"}}},{"name":"recWithStringsArray","type":{"array":{"items":"TestModel.RecordWithStrings"}}}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithFixedVectors","fields":[{"name":"fixedIntVector","type":{"vector":{"items":"int32","length":5}}},{"name":"fixedSimpleRecordVector","type":{"vector":{"items":"TestModel.SimpleRecord","length":3}}},{"name":"fixedRecordWithVlensVector","type":{"vector":{"items":"TestModel.RecordWithVlens","length":2}}}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"RecordWithOptionalFields","fields":[{"name":"optionalInt","type":[null,"int32"]},{"name":"optionalIntAlternateSyntax","type":[null,"int32"]},{"name":"optionalTime","type":[null,"time"]}]},{"name":"RecordWithStrings","fields":[{"name":"a","type":"string"},{"name":"b","type":"string"}]},{"name":"RecordWithVlens","fields":[{"name":"a","type":{"vector":{"items":"TestModel.SimpleRecord"}}},{"name":"b","type":"int32"},{"name":"c","type":"int32"}]},{"name":"SimpleRecord","fields":[{"name":"x","type":"int32"},{"name":"y","type":"int32"},{"name":"z","type":"int32"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]})"; std::vector EnumsWriterBase::previous_schemas_ = { }; @@ -4856,11 +4871,56 @@ void EnumsWriterBase::WriteRec(test_model::RecordWithEnums const& value) { state_ = 4; } -void EnumsWriterBase::Close() { +void EnumsWriterBase::WriteRecArray(yardl::DynamicNDArray const& value) { if (unlikely(state_ != 4)) { EnumsWriterBaseInvalidState(4, false, state_); } + WriteRecArrayImpl(value); + state_ = 5; +} + +void EnumsWriterBase::WriteRecWithFixedVectorsArray(yardl::DynamicNDArray const& value) { + if (unlikely(state_ != 5)) { + EnumsWriterBaseInvalidState(5, false, state_); + } + + WriteRecWithFixedVectorsArrayImpl(value); + state_ = 6; +} + +void EnumsWriterBase::WriteRecWithOptionalFieldsArray(yardl::DynamicNDArray const& value) { + if (unlikely(state_ != 6)) { + EnumsWriterBaseInvalidState(6, false, state_); + } + + WriteRecWithOptionalFieldsArrayImpl(value); + state_ = 7; +} + +void EnumsWriterBase::WriteRecWithVlensArray(yardl::DynamicNDArray const& value) { + if (unlikely(state_ != 7)) { + EnumsWriterBaseInvalidState(7, false, state_); + } + + WriteRecWithVlensArrayImpl(value); + state_ = 8; +} + +void EnumsWriterBase::WriteRecWithStringsArray(yardl::DynamicNDArray const& value) { + if (unlikely(state_ != 8)) { + EnumsWriterBaseInvalidState(8, false, state_); + } + + WriteRecWithStringsArrayImpl(value); + state_ = 9; +} + +void EnumsWriterBase::Close() { + if (unlikely(state_ != 9)) { + EnumsWriterBaseInvalidState(9, false, state_); + } + CloseImpl(); } @@ -4910,11 +4970,56 @@ void EnumsReaderBase::ReadRec(test_model::RecordWithEnums& value) { state_ = 8; } -void EnumsReaderBase::Close() { - if (!skip_completed_check_ && unlikely(state_ != 8)) { +void EnumsReaderBase::ReadRecArray(yardl::DynamicNDArray& value) { + if (unlikely(state_ != 8)) { EnumsReaderBaseInvalidState(8, state_); } + ReadRecArrayImpl(value); + state_ = 10; +} + +void EnumsReaderBase::ReadRecWithFixedVectorsArray(yardl::DynamicNDArray& value) { + if (unlikely(state_ != 10)) { + EnumsReaderBaseInvalidState(10, state_); + } + + ReadRecWithFixedVectorsArrayImpl(value); + state_ = 12; +} + +void EnumsReaderBase::ReadRecWithOptionalFieldsArray(yardl::DynamicNDArray& value) { + if (unlikely(state_ != 12)) { + EnumsReaderBaseInvalidState(12, state_); + } + + ReadRecWithOptionalFieldsArrayImpl(value); + state_ = 14; +} + +void EnumsReaderBase::ReadRecWithVlensArray(yardl::DynamicNDArray& value) { + if (unlikely(state_ != 14)) { + EnumsReaderBaseInvalidState(14, state_); + } + + ReadRecWithVlensArrayImpl(value); + state_ = 16; +} + +void EnumsReaderBase::ReadRecWithStringsArray(yardl::DynamicNDArray& value) { + if (unlikely(state_ != 16)) { + EnumsReaderBaseInvalidState(16, state_); + } + + ReadRecWithStringsArrayImpl(value); + state_ = 18; +} + +void EnumsReaderBase::Close() { + if (!skip_completed_check_ && unlikely(state_ != 18)) { + EnumsReaderBaseInvalidState(18, state_); + } + CloseImpl(); } void EnumsReaderBase::CopyTo(EnumsWriterBase& writer) { @@ -4938,6 +5043,31 @@ void EnumsReaderBase::CopyTo(EnumsWriterBase& writer) { ReadRec(value); writer.WriteRec(value); } + { + yardl::DynamicNDArray value; + ReadRecArray(value); + writer.WriteRecArray(value); + } + { + yardl::DynamicNDArray value; + ReadRecWithFixedVectorsArray(value); + writer.WriteRecWithFixedVectorsArray(value); + } + { + yardl::DynamicNDArray value; + ReadRecWithOptionalFieldsArray(value); + writer.WriteRecWithOptionalFieldsArray(value); + } + { + yardl::DynamicNDArray value; + ReadRecWithVlensArray(value); + writer.WriteRecWithVlensArray(value); + } + { + yardl::DynamicNDArray value; + ReadRecWithStringsArray(value); + writer.WriteRecWithStringsArray(value); + } } namespace { diff --git a/cpp/test/generated/protocols.h b/cpp/test/generated/protocols.h index 7d1bc420..6dc55ef8 100644 --- a/cpp/test/generated/protocols.h +++ b/cpp/test/generated/protocols.h @@ -2124,6 +2124,21 @@ class EnumsWriterBase { // Ordinal 3. void WriteRec(test_model::RecordWithEnums const& value); + // Ordinal 4. + void WriteRecArray(yardl::DynamicNDArray const& value); + + // Ordinal 5. + void WriteRecWithFixedVectorsArray(yardl::DynamicNDArray const& value); + + // Ordinal 6. + void WriteRecWithOptionalFieldsArray(yardl::DynamicNDArray const& value); + + // Ordinal 7. + void WriteRecWithVlensArray(yardl::DynamicNDArray const& value); + + // Ordinal 8. + void WriteRecWithStringsArray(yardl::DynamicNDArray const& value); + // Optionaly close this writer before destructing. Validates that all steps were completed. void Close(); @@ -2137,6 +2152,11 @@ class EnumsWriterBase { virtual void WriteVecImpl(std::vector const& value) = 0; virtual void WriteSizeImpl(test_model::SizeBasedEnum const& value) = 0; virtual void WriteRecImpl(test_model::RecordWithEnums const& value) = 0; + virtual void WriteRecArrayImpl(yardl::DynamicNDArray const& value) = 0; + virtual void WriteRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray const& value) = 0; + virtual void WriteRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray const& value) = 0; + virtual void WriteRecWithVlensArrayImpl(yardl::DynamicNDArray const& value) = 0; + virtual void WriteRecWithStringsArrayImpl(yardl::DynamicNDArray const& value) = 0; virtual void CloseImpl() {} static std::string schema_; @@ -2168,6 +2188,21 @@ class EnumsReaderBase { // Ordinal 3. void ReadRec(test_model::RecordWithEnums& value); + // Ordinal 4. + void ReadRecArray(yardl::DynamicNDArray& value); + + // Ordinal 5. + void ReadRecWithFixedVectorsArray(yardl::DynamicNDArray& value); + + // Ordinal 6. + void ReadRecWithOptionalFieldsArray(yardl::DynamicNDArray& value); + + // Ordinal 7. + void ReadRecWithVlensArray(yardl::DynamicNDArray& value); + + // Ordinal 8. + void ReadRecWithStringsArray(yardl::DynamicNDArray& value); + // Optionaly close this writer before destructing. Validates that all steps were completely read. void Close(); @@ -2180,6 +2215,11 @@ class EnumsReaderBase { virtual void ReadVecImpl(std::vector& value) = 0; virtual void ReadSizeImpl(test_model::SizeBasedEnum& value) = 0; virtual void ReadRecImpl(test_model::RecordWithEnums& value) = 0; + virtual void ReadRecArrayImpl(yardl::DynamicNDArray& value) = 0; + virtual void ReadRecWithFixedVectorsArrayImpl(yardl::DynamicNDArray& value) = 0; + virtual void ReadRecWithOptionalFieldsArrayImpl(yardl::DynamicNDArray& value) = 0; + virtual void ReadRecWithVlensArrayImpl(yardl::DynamicNDArray& value) = 0; + virtual void ReadRecWithStringsArrayImpl(yardl::DynamicNDArray& value) = 0; virtual void CloseImpl() {} static std::string schema_; diff --git a/cpp/test/roundtrip_test.cc b/cpp/test/roundtrip_test.cc index ae1a4678..068c1277 100644 --- a/cpp/test/roundtrip_test.cc +++ b/cpp/test/roundtrip_test.cc @@ -410,6 +410,37 @@ TEST_P(RoundTripTests, Enums) { tw->WriteSize(SizeBasedEnum::kC); tw->WriteRec(RecordWithEnums{Fruits::kBanana, DaysOfWeek::kMonday, TextFormat::kBold, RecordWithNoDefaultEnum{Fruits::kPear}}); + tw->WriteRecArray({ + RecordWithEnums{Fruits::kPear, DaysOfWeek::kMonday, TextFormat::kBold, RecordWithNoDefaultEnum{Fruits::kBanana}}, + RecordWithEnums{Fruits::kApple, DaysOfWeek(), TextFormat::kRegular, RecordWithNoDefaultEnum{Fruits::kApple}}, + }); + + tw->WriteRecWithFixedVectorsArray({ + RecordWithFixedVectors{ + {1, 2, 3, 4, 5}, + {SimpleRecord{1, 2, 3}, SimpleRecord{4, 5, 6}, SimpleRecord{7, 8, 9}}, + {RecordWithVlens{{{SimpleRecord{1, 2, 3}}}, -7, 22}, RecordWithVlens{{{SimpleRecord{4, 5, 6}, SimpleRecord{7, 8, 9}}}, 11, 13}}}, + RecordWithFixedVectors{ + {6, 7, 8, 9, 10}, + {SimpleRecord{10, 11, 12}, SimpleRecord{13, 14, 15}, SimpleRecord{16, 17, 18}}, + {RecordWithVlens{{}, 0, 0}, RecordWithVlens{{{SimpleRecord{2, 3, 4}}}, 1, 2}}}, + }); + + tw->WriteRecWithOptionalFieldsArray({ + RecordWithOptionalFields{5, std::nullopt, std::nullopt}, + RecordWithOptionalFields{std::nullopt, 9, std::nullopt}, + }); + + tw->WriteRecWithVlensArray({ + RecordWithVlens{{{SimpleRecord{1, 2, 3}}}, -7, 22}, + RecordWithVlens{{{SimpleRecord{4, 5, 6}, SimpleRecord{7, 8, 9}}}, 11, 13}, + }); + + tw->WriteRecWithStringsArray({ + RecordWithStrings{"hello", "world"}, + RecordWithStrings{"", "yardl"}, + }); + tw->Close(); } diff --git a/matlab/generated/+test_model/+binary/EnumsReader.m b/matlab/generated/+test_model/+binary/EnumsReader.m index 6d54b243..c75f84d8 100644 --- a/matlab/generated/+test_model/+binary/EnumsReader.m +++ b/matlab/generated/+test_model/+binary/EnumsReader.m @@ -7,6 +7,11 @@ vec_serializer size_serializer rec_serializer + rec_array_serializer + rec_with_fixed_vectors_array_serializer + rec_with_optional_fields_array_serializer + rec_with_vlens_array_serializer + rec_with_strings_array_serializer end methods @@ -21,6 +26,11 @@ self.vec_serializer = yardl.binary.VectorSerializer(yardl.binary.EnumSerializer('basic_types.Fruits', @basic_types.Fruits, yardl.binary.Int32Serializer)); self.size_serializer = yardl.binary.EnumSerializer('test_model.SizeBasedEnum', @test_model.SizeBasedEnum, yardl.binary.SizeSerializer); self.rec_serializer = test_model.binary.RecordWithEnumsSerializer(); + self.rec_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithEnumsSerializer()); + self.rec_with_fixed_vectors_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithFixedVectorsSerializer()); + self.rec_with_optional_fields_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithOptionalFieldsSerializer()); + self.rec_with_vlens_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithVlensSerializer()); + self.rec_with_strings_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithStringsSerializer()); end end @@ -40,5 +50,25 @@ function value = read_rec_(self) value = self.rec_serializer.read(self.stream_); end + + function value = read_rec_array_(self) + value = self.rec_array_serializer.read(self.stream_); + end + + function value = read_rec_with_fixed_vectors_array_(self) + value = self.rec_with_fixed_vectors_array_serializer.read(self.stream_); + end + + function value = read_rec_with_optional_fields_array_(self) + value = self.rec_with_optional_fields_array_serializer.read(self.stream_); + end + + function value = read_rec_with_vlens_array_(self) + value = self.rec_with_vlens_array_serializer.read(self.stream_); + end + + function value = read_rec_with_strings_array_(self) + value = self.rec_with_strings_array_serializer.read(self.stream_); + end end end diff --git a/matlab/generated/+test_model/+binary/EnumsWriter.m b/matlab/generated/+test_model/+binary/EnumsWriter.m index 60b41ffb..b8bd1ca7 100644 --- a/matlab/generated/+test_model/+binary/EnumsWriter.m +++ b/matlab/generated/+test_model/+binary/EnumsWriter.m @@ -7,6 +7,11 @@ vec_serializer size_serializer rec_serializer + rec_array_serializer + rec_with_fixed_vectors_array_serializer + rec_with_optional_fields_array_serializer + rec_with_vlens_array_serializer + rec_with_strings_array_serializer end methods @@ -17,6 +22,11 @@ self.vec_serializer = yardl.binary.VectorSerializer(yardl.binary.EnumSerializer('basic_types.Fruits', @basic_types.Fruits, yardl.binary.Int32Serializer)); self.size_serializer = yardl.binary.EnumSerializer('test_model.SizeBasedEnum', @test_model.SizeBasedEnum, yardl.binary.SizeSerializer); self.rec_serializer = test_model.binary.RecordWithEnumsSerializer(); + self.rec_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithEnumsSerializer()); + self.rec_with_fixed_vectors_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithFixedVectorsSerializer()); + self.rec_with_optional_fields_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithOptionalFieldsSerializer()); + self.rec_with_vlens_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithVlensSerializer()); + self.rec_with_strings_array_serializer = yardl.binary.DynamicNDArraySerializer(test_model.binary.RecordWithStringsSerializer()); end end @@ -36,5 +46,25 @@ function write_size_(self, value) function write_rec_(self, value) self.rec_serializer.write(self.stream_, value); end + + function write_rec_array_(self, value) + self.rec_array_serializer.write(self.stream_, value); + end + + function write_rec_with_fixed_vectors_array_(self, value) + self.rec_with_fixed_vectors_array_serializer.write(self.stream_, value); + end + + function write_rec_with_optional_fields_array_(self, value) + self.rec_with_optional_fields_array_serializer.write(self.stream_, value); + end + + function write_rec_with_vlens_array_(self, value) + self.rec_with_vlens_array_serializer.write(self.stream_, value); + end + + function write_rec_with_strings_array_(self, value) + self.rec_with_strings_array_serializer.write(self.stream_, value); + end end end diff --git a/matlab/generated/+test_model/+testing/MockEnumsWriter.m b/matlab/generated/+test_model/+testing/MockEnumsWriter.m index 54f4ec00..142c185b 100644 --- a/matlab/generated/+test_model/+testing/MockEnumsWriter.m +++ b/matlab/generated/+test_model/+testing/MockEnumsWriter.m @@ -7,6 +7,11 @@ expected_vec expected_size expected_rec + expected_rec_array + expected_rec_with_fixed_vectors_array + expected_rec_with_optional_fields_array + expected_rec_with_vlens_array + expected_rec_with_strings_array end methods @@ -16,6 +21,11 @@ self.expected_vec = yardl.None; self.expected_size = yardl.None; self.expected_rec = yardl.None; + self.expected_rec_array = yardl.None; + self.expected_rec_with_fixed_vectors_array = yardl.None; + self.expected_rec_with_optional_fields_array = yardl.None; + self.expected_rec_with_vlens_array = yardl.None; + self.expected_rec_with_strings_array = yardl.None; end function expect_write_single_(self, value) @@ -34,11 +44,36 @@ function expect_write_rec_(self, value) self.expected_rec = yardl.Optional(value); end + function expect_write_rec_array_(self, value) + self.expected_rec_array = yardl.Optional(value); + end + + function expect_write_rec_with_fixed_vectors_array_(self, value) + self.expected_rec_with_fixed_vectors_array = yardl.Optional(value); + end + + function expect_write_rec_with_optional_fields_array_(self, value) + self.expected_rec_with_optional_fields_array = yardl.Optional(value); + end + + function expect_write_rec_with_vlens_array_(self, value) + self.expected_rec_with_vlens_array = yardl.Optional(value); + end + + function expect_write_rec_with_strings_array_(self, value) + self.expected_rec_with_strings_array = yardl.Optional(value); + end + function verify(self) self.testCase_.verifyEqual(self.expected_single, yardl.None, "Expected call to write_single_ was not received"); self.testCase_.verifyEqual(self.expected_vec, yardl.None, "Expected call to write_vec_ was not received"); self.testCase_.verifyEqual(self.expected_size, yardl.None, "Expected call to write_size_ was not received"); self.testCase_.verifyEqual(self.expected_rec, yardl.None, "Expected call to write_rec_ was not received"); + self.testCase_.verifyEqual(self.expected_rec_array, yardl.None, "Expected call to write_rec_array_ was not received"); + self.testCase_.verifyEqual(self.expected_rec_with_fixed_vectors_array, yardl.None, "Expected call to write_rec_with_fixed_vectors_array_ was not received"); + self.testCase_.verifyEqual(self.expected_rec_with_optional_fields_array, yardl.None, "Expected call to write_rec_with_optional_fields_array_ was not received"); + self.testCase_.verifyEqual(self.expected_rec_with_vlens_array, yardl.None, "Expected call to write_rec_with_vlens_array_ was not received"); + self.testCase_.verifyEqual(self.expected_rec_with_strings_array, yardl.None, "Expected call to write_rec_with_strings_array_ was not received"); end end @@ -67,6 +102,36 @@ function write_rec_(self, value) self.expected_rec = yardl.None; end + function write_rec_array_(self, value) + self.testCase_.verifyTrue(self.expected_rec_array.has_value(), "Unexpected call to write_rec_array_"); + self.testCase_.verifyEqual(value, self.expected_rec_array.value, "Unexpected argument value for call to write_rec_array_"); + self.expected_rec_array = yardl.None; + end + + function write_rec_with_fixed_vectors_array_(self, value) + self.testCase_.verifyTrue(self.expected_rec_with_fixed_vectors_array.has_value(), "Unexpected call to write_rec_with_fixed_vectors_array_"); + self.testCase_.verifyEqual(value, self.expected_rec_with_fixed_vectors_array.value, "Unexpected argument value for call to write_rec_with_fixed_vectors_array_"); + self.expected_rec_with_fixed_vectors_array = yardl.None; + end + + function write_rec_with_optional_fields_array_(self, value) + self.testCase_.verifyTrue(self.expected_rec_with_optional_fields_array.has_value(), "Unexpected call to write_rec_with_optional_fields_array_"); + self.testCase_.verifyEqual(value, self.expected_rec_with_optional_fields_array.value, "Unexpected argument value for call to write_rec_with_optional_fields_array_"); + self.expected_rec_with_optional_fields_array = yardl.None; + end + + function write_rec_with_vlens_array_(self, value) + self.testCase_.verifyTrue(self.expected_rec_with_vlens_array.has_value(), "Unexpected call to write_rec_with_vlens_array_"); + self.testCase_.verifyEqual(value, self.expected_rec_with_vlens_array.value, "Unexpected argument value for call to write_rec_with_vlens_array_"); + self.expected_rec_with_vlens_array = yardl.None; + end + + function write_rec_with_strings_array_(self, value) + self.testCase_.verifyTrue(self.expected_rec_with_strings_array.has_value(), "Unexpected call to write_rec_with_strings_array_"); + self.testCase_.verifyEqual(value, self.expected_rec_with_strings_array.value, "Unexpected argument value for call to write_rec_with_strings_array_"); + self.expected_rec_with_strings_array = yardl.None; + end + function close_(self) end function end_stream_(self) diff --git a/matlab/generated/+test_model/+testing/TestEnumsWriter.m b/matlab/generated/+test_model/+testing/TestEnumsWriter.m index 999db3ee..fd470fca 100644 --- a/matlab/generated/+test_model/+testing/TestEnumsWriter.m +++ b/matlab/generated/+test_model/+testing/TestEnumsWriter.m @@ -50,6 +50,31 @@ function write_rec_(self, value) self.mock_writer_.expect_write_rec_(value); end + function write_rec_array_(self, value) + self.writer_.write_rec_array(value); + self.mock_writer_.expect_write_rec_array_(value); + end + + function write_rec_with_fixed_vectors_array_(self, value) + self.writer_.write_rec_with_fixed_vectors_array(value); + self.mock_writer_.expect_write_rec_with_fixed_vectors_array_(value); + end + + function write_rec_with_optional_fields_array_(self, value) + self.writer_.write_rec_with_optional_fields_array(value); + self.mock_writer_.expect_write_rec_with_optional_fields_array_(value); + end + + function write_rec_with_vlens_array_(self, value) + self.writer_.write_rec_with_vlens_array(value); + self.mock_writer_.expect_write_rec_with_vlens_array_(value); + end + + function write_rec_with_strings_array_(self, value) + self.writer_.write_rec_with_strings_array(value); + self.mock_writer_.expect_write_rec_with_strings_array_(value); + end + function close_(self) self.close_called_ = true; self.writer_.close(); diff --git a/matlab/generated/+test_model/EnumsReaderBase.m b/matlab/generated/+test_model/EnumsReaderBase.m index a830e9c5..f8380d5a 100644 --- a/matlab/generated/+test_model/EnumsReaderBase.m +++ b/matlab/generated/+test_model/EnumsReaderBase.m @@ -17,7 +17,7 @@ function close(self) self.close_(); - if ~self.skip_completed_check_ && self.state_ ~= 4 + if ~self.skip_completed_check_ && self.state_ ~= 9 expected_method = self.state_to_method_name_(self.state_); throw(yardl.ProtocolError("Protocol reader closed before all data was consumed. Expected call to '%s'.", expected_method)); end @@ -63,11 +63,66 @@ function close(self) self.state_ = 4; end + % Ordinal 4 + function value = read_rec_array(self) + if self.state_ ~= 4 + self.raise_unexpected_state_(4); + end + + value = self.read_rec_array_(); + self.state_ = 5; + end + + % Ordinal 5 + function value = read_rec_with_fixed_vectors_array(self) + if self.state_ ~= 5 + self.raise_unexpected_state_(5); + end + + value = self.read_rec_with_fixed_vectors_array_(); + self.state_ = 6; + end + + % Ordinal 6 + function value = read_rec_with_optional_fields_array(self) + if self.state_ ~= 6 + self.raise_unexpected_state_(6); + end + + value = self.read_rec_with_optional_fields_array_(); + self.state_ = 7; + end + + % Ordinal 7 + function value = read_rec_with_vlens_array(self) + if self.state_ ~= 7 + self.raise_unexpected_state_(7); + end + + value = self.read_rec_with_vlens_array_(); + self.state_ = 8; + end + + % Ordinal 8 + function value = read_rec_with_strings_array(self) + if self.state_ ~= 8 + self.raise_unexpected_state_(8); + end + + value = self.read_rec_with_strings_array_(); + self.state_ = 9; + end + function copy_to(self, writer) writer.write_single(self.read_single()); writer.write_vec(self.read_vec()); writer.write_size(self.read_size()); writer.write_rec(self.read_rec()); + writer.write_rec_array(self.read_rec_array()); + writer.write_rec_with_fixed_vectors_array(self.read_rec_with_fixed_vectors_array()); + writer.write_rec_with_optional_fields_array(self.read_rec_with_optional_fields_array()); + writer.write_rec_with_vlens_array(self.read_rec_with_vlens_array()); + writer.write_rec_with_strings_array(self.read_rec_with_strings_array()); end end @@ -82,6 +137,11 @@ function copy_to(self, writer) read_vec_(self) read_size_(self) read_rec_(self) + read_rec_array_(self) + read_rec_with_fixed_vectors_array_(self) + read_rec_with_optional_fields_array_(self) + read_rec_with_vlens_array_(self) + read_rec_with_strings_array_(self) close_(self) end @@ -102,6 +162,16 @@ function raise_unexpected_state_(self, actual) name = "read_size"; elseif state == 3 name = "read_rec"; + elseif state == 4 + name = "read_rec_array"; + elseif state == 5 + name = "read_rec_with_fixed_vectors_array"; + elseif state == 6 + name = "read_rec_with_optional_fields_array"; + elseif state == 7 + name = "read_rec_with_vlens_array"; + elseif state == 8 + name = "read_rec_with_strings_array"; else name = ""; end diff --git a/matlab/generated/+test_model/EnumsWriterBase.m b/matlab/generated/+test_model/EnumsWriterBase.m index e0d5288d..28a3e9c7 100644 --- a/matlab/generated/+test_model/EnumsWriterBase.m +++ b/matlab/generated/+test_model/EnumsWriterBase.m @@ -13,7 +13,7 @@ function close(self) self.close_(); - if self.state_ ~= 4 + if self.state_ ~= 9 expected_method = self.state_to_method_name_(self.state_); throw(yardl.ProtocolError("Protocol writer closed before all steps were called. Expected call to '%s'.", expected_method)); end @@ -58,11 +58,61 @@ function write_rec(self, value) self.write_rec_(value); self.state_ = 4; end + + % Ordinal 4 + function write_rec_array(self, value) + if self.state_ ~= 4 + self.raise_unexpected_state_(4); + end + + self.write_rec_array_(value); + self.state_ = 5; + end + + % Ordinal 5 + function write_rec_with_fixed_vectors_array(self, value) + if self.state_ ~= 5 + self.raise_unexpected_state_(5); + end + + self.write_rec_with_fixed_vectors_array_(value); + self.state_ = 6; + end + + % Ordinal 6 + function write_rec_with_optional_fields_array(self, value) + if self.state_ ~= 6 + self.raise_unexpected_state_(6); + end + + self.write_rec_with_optional_fields_array_(value); + self.state_ = 7; + end + + % Ordinal 7 + function write_rec_with_vlens_array(self, value) + if self.state_ ~= 7 + self.raise_unexpected_state_(7); + end + + self.write_rec_with_vlens_array_(value); + self.state_ = 8; + end + + % Ordinal 8 + function write_rec_with_strings_array(self, value) + if self.state_ ~= 8 + self.raise_unexpected_state_(8); + end + + self.write_rec_with_strings_array_(value); + self.state_ = 9; + end end methods (Static) function res = schema() - res = string('{"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]}'); + res = string('{"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"},{"name":"recArray","type":{"array":{"items":"TestModel.RecordWithEnums"}}},{"name":"recWithFixedVectorsArray","type":{"array":{"items":"TestModel.RecordWithFixedVectors"}}},{"name":"recWithOptionalFieldsArray","type":{"array":{"items":"TestModel.RecordWithOptionalFields"}}},{"name":"recWithVlensArray","type":{"array":{"items":"TestModel.RecordWithVlens"}}},{"name":"recWithStringsArray","type":{"array":{"items":"TestModel.RecordWithStrings"}}}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithFixedVectors","fields":[{"name":"fixedIntVector","type":{"vector":{"items":"int32","length":5}}},{"name":"fixedSimpleRecordVector","type":{"vector":{"items":"TestModel.SimpleRecord","length":3}}},{"name":"fixedRecordWithVlensVector","type":{"vector":{"items":"TestModel.RecordWithVlens","length":2}}}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"RecordWithOptionalFields","fields":[{"name":"optionalInt","type":[null,"int32"]},{"name":"optionalIntAlternateSyntax","type":[null,"int32"]},{"name":"optionalTime","type":[null,"time"]}]},{"name":"RecordWithStrings","fields":[{"name":"a","type":"string"},{"name":"b","type":"string"}]},{"name":"RecordWithVlens","fields":[{"name":"a","type":{"vector":{"items":"TestModel.SimpleRecord"}}},{"name":"b","type":"int32"},{"name":"c","type":"int32"}]},{"name":"SimpleRecord","fields":[{"name":"x","type":"int32"},{"name":"y","type":"int32"},{"name":"z","type":"int32"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]}'); end end @@ -71,6 +121,11 @@ function write_rec(self, value) write_vec_(self, value) write_size_(self, value) write_rec_(self, value) + write_rec_array_(self, value) + write_rec_with_fixed_vectors_array_(self, value) + write_rec_with_optional_fields_array_(self, value) + write_rec_with_vlens_array_(self, value) + write_rec_with_strings_array_(self, value) end_stream_(self) close_(self) @@ -92,6 +147,16 @@ function raise_unexpected_state_(self, actual) name = "write_size"; elseif state == 3 name = "write_rec"; + elseif state == 4 + name = "write_rec_array"; + elseif state == 5 + name = "write_rec_with_fixed_vectors_array"; + elseif state == 6 + name = "write_rec_with_optional_fields_array"; + elseif state == 7 + name = "write_rec_with_vlens_array"; + elseif state == 8 + name = "write_rec_with_strings_array"; else name = ''; end diff --git a/matlab/test/RoundTripTest.m b/matlab/test/RoundTripTest.m index f822b20f..fdbe67f0 100644 --- a/matlab/test/RoundTripTest.m +++ b/matlab/test/RoundTripTest.m @@ -364,6 +364,41 @@ function testEnums(testCase, format) w.write_rec(test_model.RecordWithEnums(... enum=test_model.Fruits.PEAR, ... rec=test_model.RecordWithNoDefaultEnum(enum=test_model.Fruits.BANANA))); + RE = @test_model.RecordWithEnums; + RN = @test_model.RecordWithNoDefaultEnum; + w.write_rec_array([... + RE(enum=test_model.Fruits.PEAR, rec=RN(enum=test_model.Fruits.BANANA)), ... + RE(enum=test_model.Fruits.APPLE, rec=RN(enum=test_model.Fruits.APPLE)) ... + ]); + + SR = @test_model.SimpleRecord; + RV = @test_model.RecordWithVlens; + RFV = @test_model.RecordWithFixedVectors; + w.write_rec_with_fixed_vectors_array([... + RFV(fixed_int_vector=int32([1, 2, 3, 4, 5]), ... + fixed_simple_record_vector=[SR(x=1, y=2, z=3), SR(x=4, y=5, z=6), SR(x=7, y=8, z=9)], ... + fixed_record_with_vlens_vector=[RV(a=[SR(x=1, y=2, z=3)], b=-7, c=22), RV(a=[SR(x=4, y=5, z=6), SR(x=7, y=8, z=9)], b=11, c=13)]), ... + RFV(fixed_int_vector=int32([6, 7, 8, 9, 10]), ... + fixed_simple_record_vector=[SR(x=10, y=11, z=12), SR(x=13, y=14, z=15), SR(x=16, y=17, z=18)], ... + fixed_record_with_vlens_vector=[RV(a=SR.empty(), b=0, c=0), RV(a=[SR(x=2, y=3, z=4)], b=1, c=2)]) ... + ]); + + ROF = @test_model.RecordWithOptionalFields; + w.write_rec_with_optional_fields_array([... + ROF(optional_int=int32(5)), ... + ROF(optional_int_alternate_syntax=int32(9)) ... + ]); + + w.write_rec_with_vlens_array([... + RV(a=[SR(x=1, y=2, z=3)], b=-7, c=22), ... + RV(a=[SR(x=4, y=5, z=6), SR(x=7, y=8, z=9)], b=11, c=13) ... + ]); + + RS = @test_model.RecordWithStrings; + w.write_rec_with_strings_array([... + RS(a="hello", b="world"), ... + RS(a="", b="yardl") ... + ]); w.close(); end diff --git a/models/test/unittests.yml b/models/test/unittests.yml index 7cd2f4a6..432234cf 100644 --- a/models/test/unittests.yml +++ b/models/test/unittests.yml @@ -367,6 +367,11 @@ Enums: !protocol vec: Fruits* size: SizeBasedEnum rec: RecordWithEnums + recArray: RecordWithEnums[] + recWithFixedVectorsArray: RecordWithFixedVectors[] + recWithOptionalFieldsArray: RecordWithOptionalFields[] + recWithVlensArray: RecordWithVlens[] + recWithStringsArray: RecordWithStrings[] DaysOfWeek: BasicTypes.DaysOfWeek diff --git a/python/test_model/basic_types/binary.py b/python/test_model/basic_types/binary.py index 15f6bb0d..017bb1c4 100644 --- a/python/test_model/basic_types/binary.py +++ b/python/test_model/basic_types/binary.py @@ -29,7 +29,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithString) -> N self._write(stream, value.i) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['i']) + self._write_numpy(stream, value['i']) def read(self, stream: _binary.CodedInputStream) -> RecordWithString: field_values = self._read(stream) @@ -47,7 +47,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithUnions) -> N self._write(stream, value.null_or_int_or_string, value.date_or_datetime, value.null_or_fruits_or_days_of_week, value.record_or_int) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['null_or_int_or_string'], value['date_or_datetime'], value['null_or_fruits_or_days_of_week'], value['record_or_int']) + self._write_numpy(stream, value['null_or_int_or_string'], value['date_or_datetime'], value['null_or_fruits_or_days_of_week'], value['record_or_int']) def read(self, stream: _binary.CodedInputStream) -> RecordWithUnions: field_values = self._read(stream) @@ -65,7 +65,7 @@ def write(self, stream: _binary.CodedOutputStream, value: GenericRecordWithCompu self._write(stream, value.f1) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['f1']) + self._write_numpy(stream, value['f1']) def read(self, stream: _binary.CodedInputStream) -> GenericRecordWithComputedFields[T0, T1]: field_values = self._read(stream) diff --git a/python/test_model/binary.py b/python/test_model/binary.py index 0c6afe9b..ac0cbce1 100644 --- a/python/test_model/binary.py +++ b/python/test_model/binary.py @@ -908,6 +908,21 @@ def _write_size(self, value: SizeBasedEnum) -> None: def _write_rec(self, value: RecordWithEnums) -> None: RecordWithEnumsSerializer().write(self._stream, value) + def _write_rec_array(self, value: npt.NDArray[np.void]) -> None: + _binary.DynamicNDArraySerializer(RecordWithEnumsSerializer()).write(self._stream, value) + + def _write_rec_with_fixed_vectors_array(self, value: npt.NDArray[np.void]) -> None: + _binary.DynamicNDArraySerializer(RecordWithFixedVectorsSerializer()).write(self._stream, value) + + def _write_rec_with_optional_fields_array(self, value: npt.NDArray[np.void]) -> None: + _binary.DynamicNDArraySerializer(RecordWithOptionalFieldsSerializer()).write(self._stream, value) + + def _write_rec_with_vlens_array(self, value: npt.NDArray[np.void]) -> None: + _binary.DynamicNDArraySerializer(RecordWithVlensSerializer()).write(self._stream, value) + + def _write_rec_with_strings_array(self, value: npt.NDArray[np.void]) -> None: + _binary.DynamicNDArraySerializer(RecordWithStringsSerializer()).write(self._stream, value) + class BinaryEnumsReader(_binary.BinaryProtocolReader, EnumsReaderBase): """Binary writer for the Enums protocol.""" @@ -929,6 +944,21 @@ def _read_size(self) -> SizeBasedEnum: def _read_rec(self) -> RecordWithEnums: return RecordWithEnumsSerializer().read(self._stream) + def _read_rec_array(self) -> npt.NDArray[np.void]: + return _binary.DynamicNDArraySerializer(RecordWithEnumsSerializer()).read(self._stream) + + def _read_rec_with_fixed_vectors_array(self) -> npt.NDArray[np.void]: + return _binary.DynamicNDArraySerializer(RecordWithFixedVectorsSerializer()).read(self._stream) + + def _read_rec_with_optional_fields_array(self) -> npt.NDArray[np.void]: + return _binary.DynamicNDArraySerializer(RecordWithOptionalFieldsSerializer()).read(self._stream) + + def _read_rec_with_vlens_array(self) -> npt.NDArray[np.void]: + return _binary.DynamicNDArraySerializer(RecordWithVlensSerializer()).read(self._stream) + + def _read_rec_with_strings_array(self) -> npt.NDArray[np.void]: + return _binary.DynamicNDArraySerializer(RecordWithStringsSerializer()).read(self._stream) + class BinaryFlagsWriter(_binary.BinaryProtocolWriter, FlagsWriterBase): """Binary writer for the Flags protocol.""" @@ -1309,7 +1339,7 @@ def write(self, stream: _binary.CodedOutputStream, value: SmallBenchmarkRecord) self._write(stream, value.a, value.b, value.c) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['a'], value['b'], value['c']) + self._write_numpy(stream, value['a'], value['b'], value['c']) def read(self, stream: _binary.CodedInputStream) -> SmallBenchmarkRecord: field_values = self._read(stream) @@ -1327,7 +1357,7 @@ def write(self, stream: _binary.CodedOutputStream, value: SimpleEncodingCounters self._write(stream, value.e1, value.e2, value.slice, value.repetition) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['e1'], value['e2'], value['slice'], value['repetition']) + self._write_numpy(stream, value['e1'], value['e2'], value['slice'], value['repetition']) def read(self, stream: _binary.CodedInputStream) -> SimpleEncodingCounters: field_values = self._read(stream) @@ -1345,7 +1375,7 @@ def write(self, stream: _binary.CodedOutputStream, value: SimpleAcquisition) -> self._write(stream, value.flags, value.idx, value.data, value.trajectory) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['flags'], value['idx'], value['data'], value['trajectory']) + self._write_numpy(stream, value['flags'], value['idx'], value['data'], value['trajectory']) def read(self, stream: _binary.CodedInputStream) -> SimpleAcquisition: field_values = self._read(stream) @@ -1363,7 +1393,7 @@ def write(self, stream: _binary.CodedOutputStream, value: SimpleRecord) -> None: self._write(stream, value.x, value.y, value.z) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['x'], value['y'], value['z']) + self._write_numpy(stream, value['x'], value['y'], value['z']) def read(self, stream: _binary.CodedInputStream) -> SimpleRecord: field_values = self._read(stream) @@ -1381,7 +1411,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithPrimitives) self._write(stream, value.bool_field, value.int8_field, value.uint8_field, value.int16_field, value.uint16_field, value.int32_field, value.uint32_field, value.int64_field, value.uint64_field, value.size_field, value.float32_field, value.float64_field, value.complexfloat32_field, value.complexfloat64_field, value.date_field, value.time_field, value.datetime_field) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['bool_field'], value['int8_field'], value['uint8_field'], value['int16_field'], value['uint16_field'], value['int32_field'], value['uint32_field'], value['int64_field'], value['uint64_field'], value['size_field'], value['float32_field'], value['float64_field'], value['complexfloat32_field'], value['complexfloat64_field'], value['date_field'], value['time_field'], value['datetime_field']) + self._write_numpy(stream, value['bool_field'], value['int8_field'], value['uint8_field'], value['int16_field'], value['uint16_field'], value['int32_field'], value['uint32_field'], value['int64_field'], value['uint64_field'], value['size_field'], value['float32_field'], value['float64_field'], value['complexfloat32_field'], value['complexfloat64_field'], value['date_field'], value['time_field'], value['datetime_field']) def read(self, stream: _binary.CodedInputStream) -> RecordWithPrimitives: field_values = self._read(stream) @@ -1399,7 +1429,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithPrimitiveAli self._write(stream, value.byte_field, value.int_field, value.uint_field, value.long_field, value.ulong_field, value.float_field, value.double_field, value.complexfloat_field, value.complexdouble_field) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['byte_field'], value['int_field'], value['uint_field'], value['long_field'], value['ulong_field'], value['float_field'], value['double_field'], value['complexfloat_field'], value['complexdouble_field']) + self._write_numpy(stream, value['byte_field'], value['int_field'], value['uint_field'], value['long_field'], value['ulong_field'], value['float_field'], value['double_field'], value['complexfloat_field'], value['complexdouble_field']) def read(self, stream: _binary.CodedInputStream) -> RecordWithPrimitiveAliases: field_values = self._read(stream) @@ -1417,7 +1447,7 @@ def write(self, stream: _binary.CodedOutputStream, value: TupleWithRecords) -> N self._write(stream, value.a, value.b) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['a'], value['b']) + self._write_numpy(stream, value['a'], value['b']) def read(self, stream: _binary.CodedInputStream) -> TupleWithRecords: field_values = self._read(stream) @@ -1435,7 +1465,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithVectors) -> self._write(stream, value.default_vector, value.default_vector_fixed_length, value.vector_of_vectors) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['default_vector'], value['default_vector_fixed_length'], value['vector_of_vectors']) + self._write_numpy(stream, value['default_vector'], value['default_vector_fixed_length'], value['vector_of_vectors']) def read(self, stream: _binary.CodedInputStream) -> RecordWithVectors: field_values = self._read(stream) @@ -1453,7 +1483,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithVectorOfTime self._write(stream, value.times) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['times']) + self._write_numpy(stream, value['times']) def read(self, stream: _binary.CodedInputStream) -> RecordWithVectorOfTimes: field_values = self._read(stream) @@ -1471,7 +1501,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithArrays) -> N self._write(stream, value.default_array, value.default_array_with_empty_dimension, value.rank_1_array, value.rank_2_array, value.rank_2_array_with_named_dimensions, value.rank_2_fixed_array, value.rank_2_fixed_array_with_named_dimensions, value.dynamic_array, value.array_of_vectors) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['default_array'], value['default_array_with_empty_dimension'], value['rank_1_array'], value['rank_2_array'], value['rank_2_array_with_named_dimensions'], value['rank_2_fixed_array'], value['rank_2_fixed_array_with_named_dimensions'], value['dynamic_array'], value['array_of_vectors']) + self._write_numpy(stream, value['default_array'], value['default_array_with_empty_dimension'], value['rank_1_array'], value['rank_2_array'], value['rank_2_array_with_named_dimensions'], value['rank_2_fixed_array'], value['rank_2_fixed_array_with_named_dimensions'], value['dynamic_array'], value['array_of_vectors']) def read(self, stream: _binary.CodedInputStream) -> RecordWithArrays: field_values = self._read(stream) @@ -1489,7 +1519,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithArraysSimple self._write(stream, value.default_array, value.default_array_with_empty_dimension, value.rank_1_array, value.rank_2_array, value.rank_2_array_with_named_dimensions, value.rank_2_fixed_array, value.rank_2_fixed_array_with_named_dimensions, value.dynamic_array, value.array_of_vectors) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['default_array'], value['default_array_with_empty_dimension'], value['rank_1_array'], value['rank_2_array'], value['rank_2_array_with_named_dimensions'], value['rank_2_fixed_array'], value['rank_2_fixed_array_with_named_dimensions'], value['dynamic_array'], value['array_of_vectors']) + self._write_numpy(stream, value['default_array'], value['default_array_with_empty_dimension'], value['rank_1_array'], value['rank_2_array'], value['rank_2_array_with_named_dimensions'], value['rank_2_fixed_array'], value['rank_2_fixed_array_with_named_dimensions'], value['dynamic_array'], value['array_of_vectors']) def read(self, stream: _binary.CodedInputStream) -> RecordWithArraysSimpleSyntax: field_values = self._read(stream) @@ -1507,7 +1537,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithOptionalFiel self._write(stream, value.optional_int, value.optional_int_alternate_syntax, value.optional_time) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['optional_int'], value['optional_int_alternate_syntax'], value['optional_time']) + self._write_numpy(stream, value['optional_int'], value['optional_int_alternate_syntax'], value['optional_time']) def read(self, stream: _binary.CodedInputStream) -> RecordWithOptionalFields: field_values = self._read(stream) @@ -1525,7 +1555,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithVlens) -> No self._write(stream, value.a, value.b, value.c) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['a'], value['b'], value['c']) + self._write_numpy(stream, value['a'], value['b'], value['c']) def read(self, stream: _binary.CodedInputStream) -> RecordWithVlens: field_values = self._read(stream) @@ -1543,7 +1573,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithStrings) -> self._write(stream, value.a, value.b) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['a'], value['b']) + self._write_numpy(stream, value['a'], value['b']) def read(self, stream: _binary.CodedInputStream) -> RecordWithStrings: field_values = self._read(stream) @@ -1561,7 +1591,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithOptionalVect self._write(stream, value.optional_vector) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['optional_vector']) + self._write_numpy(stream, value['optional_vector']) def read(self, stream: _binary.CodedInputStream) -> RecordWithOptionalVector: field_values = self._read(stream) @@ -1579,7 +1609,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithFixedVectors self._write(stream, value.fixed_int_vector, value.fixed_simple_record_vector, value.fixed_record_with_vlens_vector) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['fixed_int_vector'], value['fixed_simple_record_vector'], value['fixed_record_with_vlens_vector']) + self._write_numpy(stream, value['fixed_int_vector'], value['fixed_simple_record_vector'], value['fixed_record_with_vlens_vector']) def read(self, stream: _binary.CodedInputStream) -> RecordWithFixedVectors: field_values = self._read(stream) @@ -1597,7 +1627,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithFixedArrays) self._write(stream, value.ints, value.fixed_simple_record_array, value.fixed_record_with_vlens_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) + self._write_numpy(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithFixedArrays: field_values = self._read(stream) @@ -1615,7 +1645,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithNamedFixedAr self._write(stream, value.ints, value.fixed_simple_record_array, value.fixed_record_with_vlens_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) + self._write_numpy(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithNamedFixedArrays: field_values = self._read(stream) @@ -1633,7 +1663,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithNDArrays) -> self._write(stream, value.ints, value.fixed_simple_record_array, value.fixed_record_with_vlens_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) + self._write_numpy(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithNDArrays: field_values = self._read(stream) @@ -1651,7 +1681,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithNDArraysSing self._write(stream, value.ints, value.fixed_simple_record_array, value.fixed_record_with_vlens_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) + self._write_numpy(stream, value['ints'], value['fixed_simple_record_array'], value['fixed_record_with_vlens_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithNDArraysSingleDimension: field_values = self._read(stream) @@ -1669,7 +1699,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithDynamicNDArr self._write(stream, value.ints, value.simple_record_array, value.record_with_vlens_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['ints'], value['simple_record_array'], value['record_with_vlens_array']) + self._write_numpy(stream, value['ints'], value['simple_record_array'], value['record_with_vlens_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithDynamicNDArrays: field_values = self._read(stream) @@ -1687,7 +1717,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithFixedCollect self._write(stream, value.fixed_vector, value.fixed_array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['fixed_vector'], value['fixed_array']) + self._write_numpy(stream, value['fixed_vector'], value['fixed_array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithFixedCollections: field_values = self._read(stream) @@ -1705,7 +1735,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithVlenCollecti self._write(stream, value.vector, value.array) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['vector'], value['array']) + self._write_numpy(stream, value['vector'], value['array']) def read(self, stream: _binary.CodedInputStream) -> RecordWithVlenCollections: field_values = self._read(stream) @@ -1723,7 +1753,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithUnionsOfCont self._write(stream, value.map_or_scalar, value.vector_or_scalar, value.array_or_scalar) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['map_or_scalar'], value['vector_or_scalar'], value['array_or_scalar']) + self._write_numpy(stream, value['map_or_scalar'], value['vector_or_scalar'], value['array_or_scalar']) def read(self, stream: _binary.CodedInputStream) -> RecordWithUnionsOfContainers: field_values = self._read(stream) @@ -1741,7 +1771,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithMaps) -> Non self._write(stream, value.set_1, value.set_2, value.set_3) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['set_1'], value['set_2'], value['set_3']) + self._write_numpy(stream, value['set_1'], value['set_2'], value['set_3']) def read(self, stream: _binary.CodedInputStream) -> RecordWithMaps: field_values = self._read(stream) @@ -1759,7 +1789,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithNoDefaultEnu self._write(stream, value.enum) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['enum']) + self._write_numpy(stream, value['enum']) def read(self, stream: _binary.CodedInputStream) -> RecordWithNoDefaultEnum: field_values = self._read(stream) @@ -1777,7 +1807,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithEnums) -> No self._write(stream, value.enum, value.flags, value.flags_2, value.rec) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['enum'], value['flags'], value['flags_2'], value['rec']) + self._write_numpy(stream, value['enum'], value['flags'], value['flags_2'], value['rec']) def read(self, stream: _binary.CodedInputStream) -> RecordWithEnums: field_values = self._read(stream) @@ -1795,7 +1825,7 @@ def write(self, stream: _binary.CodedOutputStream, value: GenericRecord[T1, T2, self._write(stream, value.scalar_1, value.scalar_2, value.vector_1, value.image_2) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['scalar_1'], value['scalar_2'], value['vector_1'], value['image_2']) + self._write_numpy(stream, value['scalar_1'], value['scalar_2'], value['vector_1'], value['image_2']) def read(self, stream: _binary.CodedInputStream) -> GenericRecord[T1, T2, T2_NP]: field_values = self._read(stream) @@ -1813,7 +1843,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithAliasedGener self._write(stream, value.my_strings, value.aliased_strings) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['my_strings'], value['aliased_strings']) + self._write_numpy(stream, value['my_strings'], value['aliased_strings']) def read(self, stream: _binary.CodedInputStream) -> RecordWithAliasedGenerics: field_values = self._read(stream) @@ -1831,7 +1861,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithGenericVecto self._write(stream, value.v) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v']) + self._write_numpy(stream, value['v']) def read(self, stream: _binary.CodedInputStream) -> RecordWithGenericVectorOfRecords[T, U, U_NP]: field_values = self._read(stream) @@ -1849,7 +1879,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithOptionalGene self._write(stream, value.v) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v']) + self._write_numpy(stream, value['v']) def read(self, stream: _binary.CodedInputStream) -> RecordWithOptionalGenericField[T]: field_values = self._read(stream) @@ -1867,7 +1897,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithAliasedOptio self._write(stream, value.v) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v']) + self._write_numpy(stream, value['v']) def read(self, stream: _binary.CodedInputStream) -> RecordWithAliasedOptionalGenericField[T]: field_values = self._read(stream) @@ -1885,7 +1915,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithOptionalGene self._write(stream, value.v) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v']) + self._write_numpy(stream, value['v']) def read(self, stream: _binary.CodedInputStream) -> RecordWithOptionalGenericUnionField[U, V]: field_values = self._read(stream) @@ -1903,7 +1933,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithAliasedOptio self._write(stream, value.v) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v']) + self._write_numpy(stream, value['v']) def read(self, stream: _binary.CodedInputStream) -> RecordWithAliasedOptionalGenericUnionField[U, V]: field_values = self._read(stream) @@ -1921,7 +1951,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithGenericVecto self._write(stream, value.v, value.av) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v'], value['av']) + self._write_numpy(stream, value['v'], value['av']) def read(self, stream: _binary.CodedInputStream) -> RecordWithGenericVectors[T]: field_values = self._read(stream) @@ -1939,7 +1969,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithGenericFixed self._write(stream, value.fv, value.afv) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['fv'], value['afv']) + self._write_numpy(stream, value['fv'], value['afv']) def read(self, stream: _binary.CodedInputStream) -> RecordWithGenericFixedVectors[T]: field_values = self._read(stream) @@ -1957,7 +1987,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithGenericArray self._write(stream, value.nd, value.fixed_nd, value.dynamic_nd, value.aliased_nd, value.aliased_fixed_nd, value.aliased_dynamic_nd) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['nd'], value['fixed_nd'], value['dynamic_nd'], value['aliased_nd'], value['aliased_fixed_nd'], value['aliased_dynamic_nd']) + self._write_numpy(stream, value['nd'], value['fixed_nd'], value['dynamic_nd'], value['aliased_nd'], value['aliased_fixed_nd'], value['aliased_dynamic_nd']) def read(self, stream: _binary.CodedInputStream) -> RecordWithGenericArrays[T_NP]: field_values = self._read(stream) @@ -1975,7 +2005,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithGenericMaps[ self._write(stream, value.m, value.am) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['m'], value['am']) + self._write_numpy(stream, value['m'], value['am']) def read(self, stream: _binary.CodedInputStream) -> RecordWithGenericMaps[T, U]: field_values = self._read(stream) @@ -1993,7 +2023,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordContainingGeneri self._write(stream, value.g1, value.g1a, value.g2, value.g2a, value.g3, value.g3a, value.g4, value.g5, value.g6, value.g7) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['g1'], value['g1a'], value['g2'], value['g2a'], value['g3'], value['g3a'], value['g4'], value['g5'], value['g6'], value['g7']) + self._write_numpy(stream, value['g1'], value['g1a'], value['g2'], value['g2a'], value['g3'], value['g3a'], value['g4'], value['g5'], value['g6'], value['g7']) def read(self, stream: _binary.CodedInputStream) -> RecordContainingGenericRecords[A, B, B_NP]: field_values = self._read(stream) @@ -2011,7 +2041,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordContainingNested self._write(stream, value.f1, value.f1a, value.f2, value.f2a, value.nested) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['f1'], value['f1a'], value['f2'], value['f2a'], value['nested']) + self._write_numpy(stream, value['f1'], value['f1a'], value['f2'], value['f2a'], value['nested']) def read(self, stream: _binary.CodedInputStream) -> RecordContainingNestedGenericRecords: field_values = self._read(stream) @@ -2029,7 +2059,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordContainingVector self._write(stream, value.strings, value.maps, value.arrays, value.tuples) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['strings'], value['maps'], value['arrays'], value['tuples']) + self._write_numpy(stream, value['strings'], value['maps'], value['arrays'], value['tuples']) def read(self, stream: _binary.CodedInputStream) -> RecordContainingVectorsOfAliases: field_values = self._read(stream) @@ -2047,7 +2077,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithComputedFiel self._write(stream, value.array_field, value.array_field_map_dimensions, value.dynamic_array_field, value.fixed_array_field, value.int_field, value.int8_field, value.uint8_field, value.int16_field, value.uint16_field, value.uint32_field, value.int64_field, value.uint64_field, value.size_field, value.float32_field, value.float64_field, value.complexfloat32_field, value.complexfloat64_field, value.string_field, value.tuple_field, value.vector_field, value.vector_of_vectors_field, value.fixed_vector_field, value.fixed_vector_of_vectors_field, value.optional_named_array, value.int_float_union, value.nullable_int_float_union, value.union_with_nested_generic_union, value.map_field) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['array_field'], value['array_field_map_dimensions'], value['dynamic_array_field'], value['fixed_array_field'], value['int_field'], value['int8_field'], value['uint8_field'], value['int16_field'], value['uint16_field'], value['uint32_field'], value['int64_field'], value['uint64_field'], value['size_field'], value['float32_field'], value['float64_field'], value['complexfloat32_field'], value['complexfloat64_field'], value['string_field'], value['tuple_field'], value['vector_field'], value['vector_of_vectors_field'], value['fixed_vector_field'], value['fixed_vector_of_vectors_field'], value['optional_named_array'], value['int_float_union'], value['nullable_int_float_union'], value['union_with_nested_generic_union'], value['map_field']) + self._write_numpy(stream, value['array_field'], value['array_field_map_dimensions'], value['dynamic_array_field'], value['fixed_array_field'], value['int_field'], value['int8_field'], value['uint8_field'], value['int16_field'], value['uint16_field'], value['uint32_field'], value['int64_field'], value['uint64_field'], value['size_field'], value['float32_field'], value['float64_field'], value['complexfloat32_field'], value['complexfloat64_field'], value['string_field'], value['tuple_field'], value['vector_field'], value['vector_of_vectors_field'], value['fixed_vector_field'], value['fixed_vector_of_vectors_field'], value['optional_named_array'], value['int_float_union'], value['nullable_int_float_union'], value['union_with_nested_generic_union'], value['map_field']) def read(self, stream: _binary.CodedInputStream) -> RecordWithComputedFields: field_values = self._read(stream) @@ -2065,7 +2095,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordNotUsedInProtoco self._write(stream, value.u1, value.u2) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['u1'], value['u2']) + self._write_numpy(stream, value['u1'], value['u2']) def read(self, stream: _binary.CodedInputStream) -> RecordNotUsedInProtocol: field_values = self._read(stream) @@ -2083,7 +2113,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithKeywordField self._write(stream, value.int_, value.sizeof, value.if_) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['int_'], value['sizeof'], value['if_']) + self._write_numpy(stream, value['int_'], value['sizeof'], value['if_']) def read(self, stream: _binary.CodedInputStream) -> RecordWithKeywordFields: field_values = self._read(stream) @@ -2101,7 +2131,7 @@ def write(self, stream: _binary.CodedOutputStream, value: RecordWithOptionalDate self._write(stream, value.date_field) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['date_field']) + self._write_numpy(stream, value['date_field']) def read(self, stream: _binary.CodedInputStream) -> RecordWithOptionalDate: field_values = self._read(stream) diff --git a/python/test_model/ndjson.py b/python/test_model/ndjson.py index a0a02387..479a8fed 100644 --- a/python/test_model/ndjson.py +++ b/python/test_model/ndjson.py @@ -3818,6 +3818,31 @@ def _write_rec(self, value: RecordWithEnums) -> None: json_value = converter.to_json(value) self._write_json_line({"rec": json_value}) + def _write_rec_array(self, value: npt.NDArray[np.void]) -> None: + converter = _ndjson.DynamicNDArrayConverter(RecordWithEnumsConverter()) + json_value = converter.to_json(value) + self._write_json_line({"recArray": json_value}) + + def _write_rec_with_fixed_vectors_array(self, value: npt.NDArray[np.void]) -> None: + converter = _ndjson.DynamicNDArrayConverter(RecordWithFixedVectorsConverter()) + json_value = converter.to_json(value) + self._write_json_line({"recWithFixedVectorsArray": json_value}) + + def _write_rec_with_optional_fields_array(self, value: npt.NDArray[np.void]) -> None: + converter = _ndjson.DynamicNDArrayConverter(RecordWithOptionalFieldsConverter()) + json_value = converter.to_json(value) + self._write_json_line({"recWithOptionalFieldsArray": json_value}) + + def _write_rec_with_vlens_array(self, value: npt.NDArray[np.void]) -> None: + converter = _ndjson.DynamicNDArrayConverter(RecordWithVlensConverter()) + json_value = converter.to_json(value) + self._write_json_line({"recWithVlensArray": json_value}) + + def _write_rec_with_strings_array(self, value: npt.NDArray[np.void]) -> None: + converter = _ndjson.DynamicNDArrayConverter(RecordWithStringsConverter()) + json_value = converter.to_json(value) + self._write_json_line({"recWithStringsArray": json_value}) + class NDJsonEnumsReader(_ndjson.NDJsonProtocolReader, EnumsReaderBase): """NDJson writer for the Enums protocol.""" @@ -3847,6 +3872,31 @@ def _read_rec(self) -> RecordWithEnums: converter = RecordWithEnumsConverter() return converter.from_json(json_object) + def _read_rec_array(self) -> npt.NDArray[np.void]: + json_object = self._read_json_line("recArray", True) + converter = _ndjson.DynamicNDArrayConverter(RecordWithEnumsConverter()) + return converter.from_json(json_object) + + def _read_rec_with_fixed_vectors_array(self) -> npt.NDArray[np.void]: + json_object = self._read_json_line("recWithFixedVectorsArray", True) + converter = _ndjson.DynamicNDArrayConverter(RecordWithFixedVectorsConverter()) + return converter.from_json(json_object) + + def _read_rec_with_optional_fields_array(self) -> npt.NDArray[np.void]: + json_object = self._read_json_line("recWithOptionalFieldsArray", True) + converter = _ndjson.DynamicNDArrayConverter(RecordWithOptionalFieldsConverter()) + return converter.from_json(json_object) + + def _read_rec_with_vlens_array(self) -> npt.NDArray[np.void]: + json_object = self._read_json_line("recWithVlensArray", True) + converter = _ndjson.DynamicNDArrayConverter(RecordWithVlensConverter()) + return converter.from_json(json_object) + + def _read_rec_with_strings_array(self) -> npt.NDArray[np.void]: + json_object = self._read_json_line("recWithStringsArray", True) + converter = _ndjson.DynamicNDArrayConverter(RecordWithStringsConverter()) + return converter.from_json(json_object) + class NDJsonFlagsWriter(_ndjson.NDJsonProtocolWriter, FlagsWriterBase): """NDJson writer for the Flags protocol.""" diff --git a/python/test_model/protocols.py b/python/test_model/protocols.py index c1edc8b0..a8043318 100644 --- a/python/test_model/protocols.py +++ b/python/test_model/protocols.py @@ -4836,11 +4836,11 @@ class EnumsWriterBase(abc.ABC): def __init__(self) -> None: self._state = 0 - schema = r"""{"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]}""" + schema = r"""{"protocol":{"name":"Enums","sequence":[{"name":"single","type":"TestModel.Fruits"},{"name":"vec","type":{"vector":{"items":"TestModel.Fruits"}}},{"name":"size","type":"TestModel.SizeBasedEnum"},{"name":"rec","type":"TestModel.RecordWithEnums"},{"name":"recArray","type":{"array":{"items":"TestModel.RecordWithEnums"}}},{"name":"recWithFixedVectorsArray","type":{"array":{"items":"TestModel.RecordWithFixedVectors"}}},{"name":"recWithOptionalFieldsArray","type":{"array":{"items":"TestModel.RecordWithOptionalFields"}}},{"name":"recWithVlensArray","type":{"array":{"items":"TestModel.RecordWithVlens"}}},{"name":"recWithStringsArray","type":{"array":{"items":"TestModel.RecordWithStrings"}}}]},"types":[{"name":"DaysOfWeek","values":[{"symbol":"monday","value":1},{"symbol":"tuesday","value":2},{"symbol":"wednesday","value":4},{"symbol":"thursday","value":8},{"symbol":"friday","value":16},{"symbol":"saturday","value":32},{"symbol":"sunday","value":64}]},{"name":"Fruits","values":[{"symbol":"apple","value":1},{"symbol":"banana","value":2},{"symbol":"pear","value":3}]},{"name":"TextFormat","base":"uint64","values":[{"symbol":"regular","value":0},{"symbol":"bold","value":1},{"symbol":"italic","value":2},{"symbol":"underline","value":4},{"symbol":"strikethrough","value":8}]},{"name":"DaysOfWeek","type":"BasicTypes.DaysOfWeek"},{"name":"Fruits","type":"BasicTypes.Fruits"},{"name":"RecordWithEnums","fields":[{"name":"enum","type":"TestModel.Fruits"},{"name":"flags","type":"TestModel.DaysOfWeek"},{"name":"flags2","type":"TestModel.TextFormat"},{"name":"rec","type":"TestModel.RecordWithNoDefaultEnum"}]},{"name":"RecordWithFixedVectors","fields":[{"name":"fixedIntVector","type":{"vector":{"items":"int32","length":5}}},{"name":"fixedSimpleRecordVector","type":{"vector":{"items":"TestModel.SimpleRecord","length":3}}},{"name":"fixedRecordWithVlensVector","type":{"vector":{"items":"TestModel.RecordWithVlens","length":2}}}]},{"name":"RecordWithNoDefaultEnum","fields":[{"name":"enum","type":"TestModel.Fruits"}]},{"name":"RecordWithOptionalFields","fields":[{"name":"optionalInt","type":[null,"int32"]},{"name":"optionalIntAlternateSyntax","type":[null,"int32"]},{"name":"optionalTime","type":[null,"time"]}]},{"name":"RecordWithStrings","fields":[{"name":"a","type":"string"},{"name":"b","type":"string"}]},{"name":"RecordWithVlens","fields":[{"name":"a","type":{"vector":{"items":"TestModel.SimpleRecord"}}},{"name":"b","type":"int32"},{"name":"c","type":"int32"}]},{"name":"SimpleRecord","fields":[{"name":"x","type":"int32"},{"name":"y","type":"int32"},{"name":"z","type":"int32"}]},{"name":"SizeBasedEnum","base":"size","values":[{"symbol":"a","value":0},{"symbol":"b","value":1},{"symbol":"c","value":2}]},{"name":"TextFormat","type":"BasicTypes.TextFormat"}]}""" def close(self) -> None: self._close() - if self._state != 8: + if self._state != 18: expected_method = self._state_to_method_name((self._state + 1) & ~1) raise ProtocolError(f"Protocol writer closed before all steps were called. Expected to call to '{expected_method}'.") @@ -4890,6 +4890,51 @@ def write_rec(self, value: RecordWithEnums) -> None: self._write_rec(value) self._state = 8 + def write_rec_array(self, value: npt.NDArray[np.void]) -> None: + """Ordinal 4""" + + if self._state != 8: + self._raise_unexpected_state(8) + + self._write_rec_array(value) + self._state = 10 + + def write_rec_with_fixed_vectors_array(self, value: npt.NDArray[np.void]) -> None: + """Ordinal 5""" + + if self._state != 10: + self._raise_unexpected_state(10) + + self._write_rec_with_fixed_vectors_array(value) + self._state = 12 + + def write_rec_with_optional_fields_array(self, value: npt.NDArray[np.void]) -> None: + """Ordinal 6""" + + if self._state != 12: + self._raise_unexpected_state(12) + + self._write_rec_with_optional_fields_array(value) + self._state = 14 + + def write_rec_with_vlens_array(self, value: npt.NDArray[np.void]) -> None: + """Ordinal 7""" + + if self._state != 14: + self._raise_unexpected_state(14) + + self._write_rec_with_vlens_array(value) + self._state = 16 + + def write_rec_with_strings_array(self, value: npt.NDArray[np.void]) -> None: + """Ordinal 8""" + + if self._state != 16: + self._raise_unexpected_state(16) + + self._write_rec_with_strings_array(value) + self._state = 18 + @abc.abstractmethod def _write_single(self, value: Fruits) -> None: raise NotImplementedError() @@ -4906,6 +4951,26 @@ def _write_size(self, value: SizeBasedEnum) -> None: def _write_rec(self, value: RecordWithEnums) -> None: raise NotImplementedError() + @abc.abstractmethod + def _write_rec_array(self, value: npt.NDArray[np.void]) -> None: + raise NotImplementedError() + + @abc.abstractmethod + def _write_rec_with_fixed_vectors_array(self, value: npt.NDArray[np.void]) -> None: + raise NotImplementedError() + + @abc.abstractmethod + def _write_rec_with_optional_fields_array(self, value: npt.NDArray[np.void]) -> None: + raise NotImplementedError() + + @abc.abstractmethod + def _write_rec_with_vlens_array(self, value: npt.NDArray[np.void]) -> None: + raise NotImplementedError() + + @abc.abstractmethod + def _write_rec_with_strings_array(self, value: npt.NDArray[np.void]) -> None: + raise NotImplementedError() + @abc.abstractmethod def _close(self) -> None: pass @@ -4928,6 +4993,16 @@ def _state_to_method_name(self, state: int) -> str: return 'write_size' if state == 6: return 'write_rec' + if state == 8: + return 'write_rec_array' + if state == 10: + return 'write_rec_with_fixed_vectors_array' + if state == 12: + return 'write_rec_with_optional_fields_array' + if state == 14: + return 'write_rec_with_vlens_array' + if state == 16: + return 'write_rec_with_strings_array' return "" class EnumsReaderBase(abc.ABC): @@ -4940,7 +5015,7 @@ def __init__(self, skip_completed_check: bool = False) -> None: def close(self) -> None: self._close() - if not self._skip_completed_check and self._state != 8: + if not self._skip_completed_check and self._state != 18: if self._state % 2 == 1: previous_method = self._state_to_method_name(self._state - 1) raise ProtocolError(f"Protocol reader closed before all data was consumed. The iterable returned by '{previous_method}' was not fully consumed.") @@ -5005,11 +5080,66 @@ def read_rec(self) -> RecordWithEnums: self._state = 8 return value + def read_rec_array(self) -> npt.NDArray[np.void]: + """Ordinal 4""" + + if self._state != 8: + self._raise_unexpected_state(8) + + value = self._read_rec_array() + self._state = 10 + return value + + def read_rec_with_fixed_vectors_array(self) -> npt.NDArray[np.void]: + """Ordinal 5""" + + if self._state != 10: + self._raise_unexpected_state(10) + + value = self._read_rec_with_fixed_vectors_array() + self._state = 12 + return value + + def read_rec_with_optional_fields_array(self) -> npt.NDArray[np.void]: + """Ordinal 6""" + + if self._state != 12: + self._raise_unexpected_state(12) + + value = self._read_rec_with_optional_fields_array() + self._state = 14 + return value + + def read_rec_with_vlens_array(self) -> npt.NDArray[np.void]: + """Ordinal 7""" + + if self._state != 14: + self._raise_unexpected_state(14) + + value = self._read_rec_with_vlens_array() + self._state = 16 + return value + + def read_rec_with_strings_array(self) -> npt.NDArray[np.void]: + """Ordinal 8""" + + if self._state != 16: + self._raise_unexpected_state(16) + + value = self._read_rec_with_strings_array() + self._state = 18 + return value + def copy_to(self, writer: EnumsWriterBase) -> None: writer.write_single(self.read_single()) writer.write_vec(self.read_vec()) writer.write_size(self.read_size()) writer.write_rec(self.read_rec()) + writer.write_rec_array(self.read_rec_array()) + writer.write_rec_with_fixed_vectors_array(self.read_rec_with_fixed_vectors_array()) + writer.write_rec_with_optional_fields_array(self.read_rec_with_optional_fields_array()) + writer.write_rec_with_vlens_array(self.read_rec_with_vlens_array()) + writer.write_rec_with_strings_array(self.read_rec_with_strings_array()) @abc.abstractmethod def _read_single(self) -> Fruits: @@ -5027,6 +5157,26 @@ def _read_size(self) -> SizeBasedEnum: def _read_rec(self) -> RecordWithEnums: raise NotImplementedError() + @abc.abstractmethod + def _read_rec_array(self) -> npt.NDArray[np.void]: + raise NotImplementedError() + + @abc.abstractmethod + def _read_rec_with_fixed_vectors_array(self) -> npt.NDArray[np.void]: + raise NotImplementedError() + + @abc.abstractmethod + def _read_rec_with_optional_fields_array(self) -> npt.NDArray[np.void]: + raise NotImplementedError() + + @abc.abstractmethod + def _read_rec_with_vlens_array(self) -> npt.NDArray[np.void]: + raise NotImplementedError() + + @abc.abstractmethod + def _read_rec_with_strings_array(self) -> npt.NDArray[np.void]: + raise NotImplementedError() + T = typing.TypeVar('T') def _wrap_iterable(self, iterable: collections.abc.Iterable[T], final_state: int) -> collections.abc.Iterable[T]: yield from iterable @@ -5050,6 +5200,16 @@ def _state_to_method_name(self, state: int) -> str: return 'read_size' if state == 6: return 'read_rec' + if state == 8: + return 'read_rec_array' + if state == 10: + return 'read_rec_with_fixed_vectors_array' + if state == 12: + return 'read_rec_with_optional_fields_array' + if state == 14: + return 'read_rec_with_vlens_array' + if state == 16: + return 'read_rec_with_strings_array' return "" class FlagsWriterBase(abc.ABC): diff --git a/python/test_model/tuples/binary.py b/python/test_model/tuples/binary.py index c5378197..5eced013 100644 --- a/python/test_model/tuples/binary.py +++ b/python/test_model/tuples/binary.py @@ -29,7 +29,7 @@ def write(self, stream: _binary.CodedOutputStream, value: Tuple[T1, T2]) -> None self._write(stream, value.v1, value.v2) def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None: - self._write(stream, value['v1'], value['v2']) + self._write_numpy(stream, value['v1'], value['v2']) def read(self, stream: _binary.CodedInputStream) -> Tuple[T1, T2]: field_values = self._read(stream) diff --git a/python/tests/test_generated_types.py b/python/tests/test_generated_types.py index 486e456c..4173d2b4 100644 --- a/python/tests/test_generated_types.py +++ b/python/tests/test_generated_types.py @@ -161,6 +161,18 @@ def test_get_dtype(): align=True, ) + # Enum fields map to their integer base dtype, so iterating a record + # array yields bare numpy scalars for those fields. + assert tm.get_dtype(tm.RecordWithEnums) == np.dtype( + [ + ("enum", " None: self.element_serializer.write(stream, element) def write_numpy(self, stream: CodedOutputStream, value: np.object_) -> None: - raise NotImplementedError("Internal error: expected this to be a subarray") + # Reached when a fixed vector is a record field written via the numpy + # record path. The value is a length-`self._length` subarray; dispatch + # each element through the element serializer's numpy path. + if len(value) != self._length: + raise ValueError( + f"Expected a subarray of length {self._length}, got {len(value)}" + ) + for element in value: + self.element_serializer.write_numpy(stream, element) def read(self, stream: CodedInputStream) -> list[T]: return [self.element_serializer.read(stream) for _ in range(self._length)] def read_numpy(self, stream: CodedInputStream) -> np.object_: - raise NotImplementedError("Internal error: expected this to be a subarray") + # Reached when a fixed vector is a record field read via the numpy + # record path. Return an array shaped like the subarray dtype slot so + # that assignment into the enclosing record is unambiguous. + result = np.ndarray( + (self._length,), dtype=self.element_serializer.overall_dtype() + ) + for i in range(self._length): + result[i] = self.element_serializer.read_numpy(stream) + return cast(np.object_, result) def is_trivially_serializable(self) -> bool: return self.element_serializer.is_trivially_serializable() @@ -1319,13 +1335,29 @@ def _write(self, stream: CodedOutputStream, *values: Any) -> None: for i, (_, serializer) in enumerate(self._field_serializers): serializer.write(stream, values[i]) + def _write_numpy(self, stream: CodedOutputStream, *values: Any) -> None: + # Each value comes from a numpy record slot, so it must be written via + # write_numpy. Dispatching through write() would mishandle enums (bare + # numpy scalars), optionals, and other fields with distinct numpy paths. + for i, (_, serializer) in enumerate(self._field_serializers): + serializer.write_numpy(stream, values[i]) + def _read(self, stream: CodedInputStream) -> tuple[Any, ...]: return tuple( serializer.read(stream) for _, serializer in self._field_serializers ) def read_numpy(self, stream: CodedInputStream) -> np.void: - return cast(np.void, self._read(stream)) + # Every field must be read via read_numpy so it yields a value that is + # assignable into the record's numpy dtype slot. read() can return a + # Python object (Enum, record, Optional, etc.) that does not fit. + return cast( + np.void, + tuple( + serializer.read_numpy(stream) + for _, serializer in self._field_serializers + ), + ) # Only used in the header