diff --git a/compiler/back_end/cpp/BUILD b/compiler/back_end/cpp/BUILD index bdd6e61..963a8f5 100644 --- a/compiler/back_end/cpp/BUILD +++ b/compiler/back_end/cpp/BUILD @@ -99,6 +99,23 @@ emboss_cc_test( ], deps = [ "//testdata:alignments_emboss", + "//runtime/cpp/test/util:noncontiguous_container", + "@com_google_googletest//:gtest_main", + ], +) + +emboss_cc_test( + name = "iterator_view_integration_test", + srcs = [ + "testcode/iterator_view_integration_test.cc", + ], + deps = [ + "//testdata:alignments_emboss", + "//testdata:condition_emboss", + "//testdata:dynamic_size_emboss", + "//testdata:uint_sizes_emboss", + "//testdata:virtual_field_emboss", + "//runtime/cpp/test/util:noncontiguous_container", "@com_google_googletest//:gtest_main", ], ) diff --git a/compiler/back_end/cpp/generated_code_templates b/compiler/back_end/cpp/generated_code_templates index e8f7c46..51b7fb1 100644 --- a/compiler/back_end/cpp/generated_code_templates +++ b/compiler/back_end/cpp/generated_code_templates @@ -250,6 +250,40 @@ MakeAligned${name}View( emboss_reserved_local_size); } +template ::value>::type> +inline Generic${name}View< + /**/ ::emboss::support::IteratorStorage> +Make${name}View(${constructor_parameters} Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return Generic${name}View< + /**/ ::emboss::support::IteratorStorage>( + ${forwarded_parameters} ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline Generic${name}View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +Make${name}View(${constructor_parameters} Container &&emboss_reserved_local_container) { + return Generic${name}View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ${forwarded_parameters} ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + // ** struct_text_stream ** //////////////////////////////////////////////////// template bool UpdateFromTextStream(Stream *emboss_reserved_local_stream) const { diff --git a/compiler/back_end/cpp/testcode/iterator_view_integration_test.cc b/compiler/back_end/cpp/testcode/iterator_view_integration_test.cc new file mode 100644 index 0000000..aef874d --- /dev/null +++ b/compiler/back_end/cpp/testcode/iterator_view_integration_test.cc @@ -0,0 +1,225 @@ +#include + +#include +#include + +#include "runtime/cpp/test/util/noncontiguous_container.h" +#include "testdata/alignments.emb.h" +#include "testdata/condition.emb.h" +#include "testdata/dynamic_size.emb.h" +#include "testdata/uint_sizes.emb.h" +#include "testdata/virtual_field.emb.h" + +namespace emboss { +namespace test { +namespace { + +template +void TestMakeAlignmentsViewIntegration() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x11), ByteT(0x22)}, + {ByteT(0x33), ByteT(0x44), ByteT(0x55)}, + {ByteT(0x66), ByteT(0x77), ByteT(0x88)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00), ByteT(0x00)}}; + + ::emboss::support::test::NoncontiguousContainer container(chunks); + + auto view = MakeAlignmentsView(container); + EXPECT_TRUE(view.Ok()); + EXPECT_EQ(view.SizeInBytes(), 28U); + + EXPECT_EQ(view.zero_offset().dummy().Read(), 0x11223344U); + EXPECT_EQ(view.three_offset().dummy().Read(), 0x44556677U); + EXPECT_EQ(view.four_offset().dummy().Read(), 0x55667788U); +} + +TEST(IteratorViewIntegrationTest, MakeAlignmentsView) { + TestMakeAlignmentsViewIntegration(); + TestMakeAlignmentsViewIntegration(); + TestMakeAlignmentsViewIntegration(); + TestMakeAlignmentsViewIntegration(); +#if __cplusplus >= 201703L + TestMakeAlignmentsViewIntegration(); + TestMakeAlignmentsViewIntegration(); +#endif +} + +// --------------------------------------------------------- +// BasicConditional from condition.emb (LittleEndian) +// 0 [+1] UInt x; if x == 0: 1 [+1] UInt xc +// --------------------------------------------------------- + +template +void TestBasicConditionalViewIntegration() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x00)}, // x == 0 + {ByteT(0xAA)} // xc == 0xAA + }; + ::emboss::support::test::NoncontiguousContainer container(chunks); + + auto view = MakeBasicConditionalView(container); + EXPECT_TRUE(view.Ok()); + EXPECT_EQ(view.SizeInBytes(), 2U); + EXPECT_EQ(view.x().Read(), 0U); + EXPECT_EQ(view.xc().Read(), 0xAAU); + + std::vector> chunks2 = { + {ByteT(0x01)}, // x == 1 + }; + ::emboss::support::test::NoncontiguousContainer container2(chunks2); + auto view2 = MakeBasicConditionalView(container2); + EXPECT_TRUE(view2.Ok()); + EXPECT_EQ(view2.SizeInBytes(), 1U); + + std::vector> chunks_fail = { + {ByteT(0x00)}, // x == 0 + }; + ::emboss::support::test::NoncontiguousContainer container_fail( + chunks_fail); + auto view_fail = MakeBasicConditionalView(container_fail); + EXPECT_FALSE(view_fail.IsComplete()); +} + +TEST(IteratorViewIntegrationTest, BasicConditional) { + TestBasicConditionalViewIntegration(); + TestBasicConditionalViewIntegration(); + TestBasicConditionalViewIntegration(); + TestBasicConditionalViewIntegration(); +#if __cplusplus >= 201703L + TestBasicConditionalViewIntegration(); + TestBasicConditionalViewIntegration(); +#endif +} + +// --------------------------------------------------------- +// AlternatingEndianSizes from uint_sizes.emb +// Mixture of LittleEndian and BigEndian +// --------------------------------------------------------- +template +void TestAlternatingEndianSizesViewIntegration() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x11)}, // one_byte (BigEndian) + {ByteT(0x22), ByteT(0x33)}, // two_byte (LittleEndian) = 0x3322 + {ByteT(0x44)}, // split... + {ByteT(0x55), ByteT(0x66)}, // three_byte (BigEndian) = 0x445566 + {ByteT(0x77), ByteT(0x88), ByteT(0x99), + ByteT(0xAA)} // four_byte (LittleEndian) = 0xAA998877 + }; + + // Adding the rest to reach 36 bytes (8 fields) + chunks.push_back(std::vector(26)); + + ::emboss::support::test::NoncontiguousContainer container(chunks); + + auto view = MakeAlternatingEndianSizesView(container); + EXPECT_TRUE(view.Ok()); + EXPECT_EQ(view.one_byte().Read(), 0x11U); + EXPECT_EQ(view.two_byte().Read(), 0x3322U); + EXPECT_EQ(view.three_byte().Read(), 0x445566U); + EXPECT_EQ(view.four_byte().Read(), 0xAA998877U); +} + +TEST(IteratorViewIntegrationTest, AlternatingEndianSizes) { + TestAlternatingEndianSizesViewIntegration(); + TestAlternatingEndianSizesViewIntegration(); + TestAlternatingEndianSizesViewIntegration(); + TestAlternatingEndianSizesViewIntegration(); +#if __cplusplus >= 201703L + TestAlternatingEndianSizesViewIntegration(); + TestAlternatingEndianSizesViewIntegration(); +#endif +} + +// --------------------------------------------------------- +// Message from dynamic_size.emb +// struct Message: +// 0 [+1] UInt header_length (h) +// 1 [+1] UInt message_length (m) +// 2 [+h-2] UInt:8[h-2] padding +// h [+m] UInt:8[m] message +// h+m [+4] UInt crc32 +// --------------------------------------------------------- +template +void TestMessageDynamicSizeIntegration() { + using ByteT = typename std::remove_const::type; + + // h = 4, m = 3 + std::vector> chunks = { + {ByteT(4)}, // header_length + {ByteT(3)}, // message_length + {ByteT(0x00), ByteT(0x00)}, // padding + {ByteT(0xAA), ByteT(0xBB)}, // message byte 0, 1 + {ByteT(0xCC)}, // message byte 2 + {ByteT(0x11), ByteT(0x22), ByteT(0x33), ByteT(0x44)} // crc32 + }; + + ::emboss::support::test::NoncontiguousContainer container(chunks); + + auto view = MakeMessageView(container); + EXPECT_TRUE(view.Ok()); + EXPECT_EQ(view.SizeInBytes(), 11U); + EXPECT_EQ(view.header_length().Read(), 4U); + EXPECT_EQ(view.message_length().Read(), 3U); + + EXPECT_EQ(view.message()[0].Read(), 0xAAU); + EXPECT_EQ(view.message()[1].Read(), 0xBBU); + EXPECT_EQ(view.message()[2].Read(), 0xCCU); + + EXPECT_EQ(view.crc32().Read(), 0x44332211U); // Little endian +} + +TEST(IteratorViewIntegrationTest, MessageDynamicSize) { + TestMessageDynamicSizeIntegration(); + TestMessageDynamicSizeIntegration(); + TestMessageDynamicSizeIntegration(); + TestMessageDynamicSizeIntegration(); +#if __cplusplus >= 201703L + TestMessageDynamicSizeIntegration(); + TestMessageDynamicSizeIntegration(); +#endif +} + +// --------------------------------------------------------- +// UsesExternalSize +// --------------------------------------------------------- +template +void TestUsesExternalSizeIntegration() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x11), ByteT(0x22), ByteT(0x33), ByteT(0x44)}, + {ByteT(0x55), ByteT(0x66), ByteT(0x77), ByteT(0x88)}, + }; + + ::emboss::support::test::NoncontiguousContainer container(chunks); + + auto view = MakeUsesExternalSizeView(container); + EXPECT_TRUE(view.Ok()); + EXPECT_EQ(view.x().value().Read(), 0x44332211U); + EXPECT_EQ(view.y().value().Read(), 0x88776655U); +} + +TEST(IteratorViewIntegrationTest, UsesExternalSize) { + TestUsesExternalSizeIntegration(); + TestUsesExternalSizeIntegration(); + TestUsesExternalSizeIntegration(); + TestUsesExternalSizeIntegration(); +#if __cplusplus >= 201703L + TestUsesExternalSizeIntegration(); + TestUsesExternalSizeIntegration(); +#endif +} + +} // namespace +} // namespace test +} // namespace emboss diff --git a/runtime/cpp/emboss_memory_util.h b/runtime/cpp/emboss_memory_util.h index fca71c9..e9ee63d 100644 --- a/runtime/cpp/emboss_memory_util.h +++ b/runtime/cpp/emboss_memory_util.h @@ -47,31 +47,29 @@ struct MemoryAccessor { using ChainedAccessor = MemoryAccessor; using Unsigned = typename LeastWidthInteger::Unsigned; - static inline Unsigned ReadLittleEndianUInt(const CharT *bytes) { + + static inline Unsigned ReadLittleEndianUInt(const CharT* bytes) { return ChainedAccessor::ReadLittleEndianUInt(bytes); } - static inline void WriteLittleEndianUInt(CharT *bytes, Unsigned value) { + + static inline void WriteLittleEndianUInt(CharT* bytes, Unsigned value) { ChainedAccessor::WriteLittleEndianUInt(bytes, value); } - static inline Unsigned ReadBigEndianUInt(const CharT *bytes) { + + static inline Unsigned ReadBigEndianUInt(const CharT* bytes) { return ChainedAccessor::ReadBigEndianUInt(bytes); } - static inline void WriteBigEndianUInt(CharT *bytes, Unsigned value) { + + static inline void WriteBigEndianUInt(CharT* bytes, Unsigned value) { ChainedAccessor::WriteBigEndianUInt(bytes, value); } }; -// The least-aligned case for MemoryAccessor is 8-bit alignment, and the default -// version of MemoryAccessor will devolve to this one if there is no more -// specific override. -// -// If the system byte order is known, then these routines can use memcpy and -// (possibly) a byte swap; otherwise they can read individual bytes and -// shift+or them together in the appropriate order. I (bolms@) haven't found a -// compiler that will optimize the multiple reads, shifts, and ors into a single -// read, so the memcpy version is *much* faster for 32-bit and larger reads. +// UnalignedAccessor provides generic, iterator-compatible read and write +// implementations for unaligned data. It uses std::copy_n to safely handle +// data movement and byte reordering across contiguous or fragmented storage. template -struct MemoryAccessor { +struct UnalignedAccessor { static_assert(kBits % 8 == 0, "MemoryAccessor can only read and write whole-byte values."); static_assert(IsAliasSafe::value, @@ -80,32 +78,65 @@ struct MemoryAccessor { using Unsigned = typename LeastWidthInteger::Unsigned; #if defined(EMBOSS_LITTLE_ENDIAN_TO_NATIVE) - static inline Unsigned ReadLittleEndianUInt(const CharT *bytes) { + template + static inline Unsigned ReadLittleEndianUInt(Iterator bytes) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); Unsigned result = 0; - ::std::memcpy(&result, bytes, kBits / 8); + auto dest = + reinterpret_cast::type*>(&result); + ::std::copy_n(bytes, kBits / 8, dest); return EMBOSS_LITTLE_ENDIAN_TO_NATIVE(result); } #else - static inline Unsigned ReadLittleEndianUInt(const CharT *bytes) { + template + static inline Unsigned ReadLittleEndianUInt(Iterator bytes) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); Unsigned result = 0; - for (decltype(kBits) i = 0; i < kBits / 8; ++i) { - result |= - static_cast(static_cast(bytes[i])) - << i * 8; + auto it = bytes; + for (decltype(kBits) i = 0; i < kBits / 8; ++i, ++it) { + result |= static_cast(static_cast(*it)) + << i * 8; } return result; } #endif #if defined(EMBOSS_NATIVE_TO_LITTLE_ENDIAN) - static inline void WriteLittleEndianUInt(CharT *bytes, Unsigned value) { + template + static inline void WriteLittleEndianUInt(Iterator bytes, Unsigned value) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); value = EMBOSS_NATIVE_TO_LITTLE_ENDIAN(value); - ::std::memcpy(bytes, &value, kBits / 8); + auto src = + reinterpret_cast::type*>(&value); + ::std::copy_n(src, kBits / 8, bytes); } #else - static inline void WriteLittleEndianUInt(CharT *bytes, Unsigned value) { - for (decltype(kBits) i = 0; i < kBits / 8; ++i) { - bytes[i] = static_cast(static_cast(value)); + template + static inline void WriteLittleEndianUInt(Iterator bytes, Unsigned value) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); + auto it = bytes; + for (decltype(kBits) i = 0; i < kBits / 8; ++i, ++it) { + *it = static_cast(static_cast(value)); if (sizeof value > 1) { // Shifting an 8-bit type by 8 bits is undefined behavior, so skip this // step for uint8_t. @@ -116,7 +147,14 @@ struct MemoryAccessor { #endif #if defined(EMBOSS_BIG_ENDIAN_TO_NATIVE) - static inline Unsigned ReadBigEndianUInt(const CharT *bytes) { + template + static inline Unsigned ReadBigEndianUInt(Iterator bytes) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); Unsigned result = 0; // When a big-endian source integer is smaller than the result, the source // bytes must be copied into the final bytes of the destination. This is @@ -160,35 +198,59 @@ struct MemoryAccessor { // +--------+--------+--------+--------+ // | 0x00 | 0x11 | 0x22 | 0x33 | // +--------+--------+--------+--------+ - ::std::memcpy(reinterpret_cast(&result) + sizeof result - kBits / 8, - bytes, kBits / 8); + auto dest = + reinterpret_cast::type*>(&result) + + sizeof(result) - kBits / 8; + ::std::copy_n(bytes, kBits / 8, dest); result = EMBOSS_BIG_ENDIAN_TO_NATIVE(result); return result; } #else - static inline Unsigned ReadBigEndianUInt(const CharT *bytes) { + template + static inline Unsigned ReadBigEndianUInt(Iterator bytes) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); Unsigned result = 0; - for (decltype(kBits) i = 0; i < kBits / 8; ++i) { - result |= - static_cast(static_cast(bytes[i])) - << (kBits - 8 - i * 8); + auto it = bytes; + for (decltype(kBits) i = 0; i < kBits / 8; ++i, ++it) { + result |= static_cast(static_cast(*it)) + << (kBits - 8 - i * 8); } return result; } #endif #if defined(EMBOSS_NATIVE_TO_BIG_ENDIAN) - static inline void WriteBigEndianUInt(CharT *bytes, Unsigned value) { + template + static inline void WriteBigEndianUInt(Iterator bytes, Unsigned value) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); value = EMBOSS_NATIVE_TO_BIG_ENDIAN(value); - ::std::memcpy(bytes, - reinterpret_cast(&value) + sizeof value - kBits / 8, - kBits / 8); + auto src = reinterpret_cast::type*>( + &value) + + sizeof(value) - kBits / 8; + ::std::copy_n(src, kBits / 8, bytes); } #else - static inline void WriteBigEndianUInt(CharT *bytes, Unsigned value) { - for (decltype(kBits) i = 0; i < kBits / 8; ++i) { - bytes[kBits / 8 - 1 - i] = - static_cast(static_cast(value)); + template + static inline void WriteBigEndianUInt(Iterator bytes, Unsigned value) { + using DereferenceT = typename ::std::remove_cv< + typename ::std::remove_reference::type>::type; + static_assert( + ::std::is_same::type>::value, + "UnalignedAccessor Iterator underlying type must match CharT."); + auto it = bytes + (kBits / 8 - 1); + for (decltype(kBits) i = 0; i < kBits / 8; ++i, --it) { + *it = static_cast(static_cast(value)); if (sizeof value > 1) { // Shifting an 8-bit type by 8 bits is undefined behavior, so skip this // step for uint8_t. @@ -199,6 +261,41 @@ struct MemoryAccessor { #endif }; +// The least-aligned case for MemoryAccessor is 8-bit alignment, and the default +// version of MemoryAccessor will devolve to this one if there is no more +// specific override. +// +// If the system byte order is known, then these routines can use memcpy and +// (possibly) a byte swap; otherwise they can read individual bytes and +// shift+or them together in the appropriate order. I (bolms@) haven't found a +// compiler that will optimize the multiple reads, shifts, and ors into a single +// read, so the memcpy version is *much* faster for 32-bit and larger reads. +template +struct MemoryAccessor { + static_assert(kBits % 8 == 0, + "MemoryAccessor can only read and write whole-byte values."); + static_assert(IsAliasSafe::value, + "MemoryAccessor can only be used on pointers to char types."); + + using Unsigned = typename LeastWidthInteger::Unsigned; + + static inline Unsigned ReadLittleEndianUInt(const CharT* bytes) { + return UnalignedAccessor::ReadLittleEndianUInt(bytes); + } + + static inline void WriteLittleEndianUInt(CharT* bytes, Unsigned value) { + UnalignedAccessor::WriteLittleEndianUInt(bytes, value); + } + + static inline Unsigned ReadBigEndianUInt(const CharT* bytes) { + return UnalignedAccessor::ReadBigEndianUInt(bytes); + } + + static inline void WriteBigEndianUInt(CharT* bytes, Unsigned value) { + UnalignedAccessor::WriteBigEndianUInt(bytes, value); + } +}; + // Specialization of UIntMemoryAccessor for 16- 32- and 64-bit-aligned reads and // writes, using EMBOSS_ALIAS_SAFE_POINTER_CAST instead of memcpy. #if defined(EMBOSS_ALIAS_SAFE_POINTER_CAST) && \ @@ -703,6 +800,205 @@ class ContiguousBuffer final { using ReadWriteContiguousBuffer = ContiguousBuffer; using ReadOnlyContiguousBuffer = ContiguousBuffer; +// IteratorStorage is a view similar to ContiguousBuffer, but instead of +// wrapping a direct pointer it wraps a generic Iterator, making it compatible +// with logically-contiguous-but-physically-fragmented backing stores. +// +// Because iterators do not guarantee or expose alignment constraints, +// IteratorStorage simply asserts 1-byte alignment internally and delegates +// unconditionally to UnalignedAccessor for all memory reads and writes. +template +class IteratorStorage final { + public: + using ByteType = typename ::std::remove_reference< + decltype(*::std::declval())>::type; + using CharT = typename ::std::remove_cv::type; + + template <::std::size_t kSubAlignment = 1, ::std::size_t kSubOffset = 0> + using OffsetStorageType = IteratorStorage; + + static_assert(IsAliasSafe::value, + "IteratorStorage requires a char type iterator."); + + // Constructs a default IteratorStorage with empty, default-constructed + // Iterators. + template ::value>::type> + IteratorStorage() : begin_(), end_() {} + + // Constructs from explicit begin and end iterators. + IteratorStorage(Iterator begin, Iterator end) + : begin_(::std::move(begin)), end_(::std::move(end)) {} + + // Constructs from a container, delegating to the (begin, end) constructor. + template ())), + Iterator>::value>::type> + explicit IteratorStorage(Container&& container) + : IteratorStorage(::std::begin(container), ::std::end(container)) {} + + // Allow implicit construction from any compatible IteratorStorage type, + // structurally enforcing convertibility via SFINAE. + template ::value>::type> + IteratorStorage(const IteratorStorage& other) + : begin_(other.begin()), end_(other.end()) {} + + // Assignment from a compatible IteratorStorage. + template ::value && + !::std::is_same::value>::type> + IteratorStorage& operator=(const IteratorStorage& other) { + begin_ = other.begin(); + end_ = other.end(); + return *this; + } + + template ::value>::type> + bool operator==(const IteratorStorage& other) const { + return begin_ == other.begin() && end_ == other.end(); + } + + template ::value>::type> + bool operator!=(const IteratorStorage& other) const { + return !(*this == other); + } + + // GetOffsetStorage returns a new IteratorStorage that points `offset` bytes + // into the current iterator. + // + // Alignment assertions are intentionally dropped since Iterators may wrap + // completely unaligned, scattered chunk pointers. The template parameters + // (kSubAlignment, kSubOffset) must be strictly maintained for compatibility + // with generated Emboss read/write recursive accessors. + template + IteratorStorage GetOffsetStorage(::std::size_t offset, + ::std::size_t size) const { + ::std::size_t available = SizeInBytes(); + ::std::size_t actual_size = + offset > available ? 0 : ::std::min(size, available - offset); + return IteratorStorage{begin_ + offset, + begin_ + offset + actual_size}; + } + + template ::value>::type> + Iterator cbegin() const { + return begin_; + } + + template ::value>::type> + Iterator cend() const { + return end_; + } + + template + typename LeastWidthInteger::Unsigned ReadLittleEndianUInt() const { + EMBOSS_CHECK_EQ(SizeInBytes() * 8, kBits); + return UncheckedReadLittleEndianUInt(); + } + + template + typename LeastWidthInteger::Unsigned UncheckedReadLittleEndianUInt() + const { + static_assert(kBits % 8 == 0, + "IteratorStorage::ReadLittleEndianUInt() can only read " + "whole-byte values."); + return UnalignedAccessor::ReadLittleEndianUInt(begin_); + } + + template + typename LeastWidthInteger::Unsigned ReadBigEndianUInt() const { + EMBOSS_CHECK_EQ(SizeInBytes() * 8, kBits); + return UncheckedReadBigEndianUInt(); + } + + template + typename LeastWidthInteger::Unsigned UncheckedReadBigEndianUInt() + const { + static_assert(kBits % 8 == 0, + "IteratorStorage::ReadBigEndianUInt() can only read " + "whole-byte values."); + return UnalignedAccessor::ReadBigEndianUInt(begin_); + } + + template + void WriteLittleEndianUInt( + typename LeastWidthInteger::Unsigned value) const { + EMBOSS_CHECK_EQ(SizeInBytes() * 8, kBits); + UncheckedWriteLittleEndianUInt(value); + } + + template + void UncheckedWriteLittleEndianUInt( + typename LeastWidthInteger::Unsigned value) const { + static_assert(kBits % 8 == 0, + "IteratorStorage::WriteLittleEndianUInt() can only write " + "whole-byte values."); + UnalignedAccessor::WriteLittleEndianUInt(begin_, value); + } + + template + void WriteBigEndianUInt( + typename LeastWidthInteger::Unsigned value) const { + EMBOSS_CHECK_EQ(SizeInBytes() * 8, kBits); + UncheckedWriteBigEndianUInt(value); + } + + template + void UncheckedWriteBigEndianUInt( + typename LeastWidthInteger::Unsigned value) const { + static_assert(kBits % 8 == 0, + "IteratorStorage::WriteBigEndianUInt() can only write " + "whole-byte values."); + UnalignedAccessor::WriteBigEndianUInt(begin_, value); + } + + template ::value>::type> + void UncheckedCopyFrom(const IteratorStorage& other, + ::std::size_t length) const { + ::std::copy_n(other.begin(), length, begin_); + } + + template ::value>::type> + void CopyFrom(const IteratorStorage& other, + ::std::size_t length) const { + EMBOSS_CHECK_LE(length, SizeInBytes()); + EMBOSS_CHECK_LE(length, other.SizeInBytes()); + UncheckedCopyFrom(other, length); + } + + bool Ok() const { return true; } + ::std::size_t SizeInBytes() const { + return static_cast<::std::size_t>(end_ - begin_); + } + Iterator begin() const { return begin_; } + Iterator end() const { return end_; } + + private: + Iterator begin_; + Iterator end_; +}; + +#if __cplusplus >= 201703L +template +IteratorStorage(Container&&) + -> IteratorStorage()))>; +#endif + // LittleEndianByteOrderer is a pass-through adapter for a byte buffer class. // It is used to implement little-endian bit blocks. // diff --git a/runtime/cpp/test/BUILD b/runtime/cpp/test/BUILD index 11c5ed6..14049e5 100644 --- a/runtime/cpp/test/BUILD +++ b/runtime/cpp/test/BUILD @@ -137,6 +137,7 @@ emboss_cc_util_test( copts = ["-DEMBOSS_FORCE_ALL_CHECKS"], deps = [ "//runtime/cpp:cpp_utils", + "//runtime/cpp/test/util:noncontiguous_container", "@com_google_googletest//:gtest_main", ], ) diff --git a/runtime/cpp/test/emboss_memory_util_test.cc b/runtime/cpp/test/emboss_memory_util_test.cc index 1831085..e6221b3 100644 --- a/runtime/cpp/test/emboss_memory_util_test.cc +++ b/runtime/cpp/test/emboss_memory_util_test.cc @@ -25,6 +25,7 @@ #include "gtest/gtest.h" #include "runtime/cpp/emboss_memory_util.h" #include "runtime/cpp/emboss_prelude.h" +#include "runtime/cpp/test/util/noncontiguous_container.h" namespace emboss { namespace support { @@ -150,6 +151,274 @@ TEST(MemoryAccessor, LittleEndianReads) { TestMemoryAccessor(); } +template +void TestIteratorUnalignedAccessor() { + using ByteT = typename std::remove_const::type; + + // Test all 2^7 = 128 possible ways to partition an 8 byte buffer into chunks. + // A 1 bit in `partition_mask` at bit `i` means a chunk boundary exists + // between byte `i` and `i + 1`. + for (uint8_t partition_mask = 0; partition_mask < 128; ++partition_mask) { + std::vector> chunks; + std::vector current_chunk; + + for (uint8_t i = 0; i < 8; ++i) { + current_chunk.push_back(ByteT(i + 1)); + if ((partition_mask & (1 << i)) || i == 7) { + chunks.push_back(std::move(current_chunk)); + current_chunk.clear(); + } + } + + NoncontiguousContainer container(chunks); + EXPECT_EQ(container.size(), 8U); + + EXPECT_EQ(0x0807060504030201UL & (~0x0UL >> (64 - kBits)), + (UnalignedAccessor::ReadLittleEndianUInt( + container.begin()))) + << "Read LE Failed. Mask = " << static_cast(partition_mask) + << "; kBits = " << kBits; + + EXPECT_EQ( + 0x0102030405060708UL >> (64 - kBits), + (UnalignedAccessor::ReadBigEndianUInt(container.begin()))) + << "Read BE Failed. Mask = " << static_cast(partition_mask) + << "; kBits = " << kBits; + + auto write_container_le = container; + UnalignedAccessor::WriteLittleEndianUInt( + write_container_le.begin(), + 0x7172737475767778UL & (~0x0UL >> (64 - kBits))); + + auto expected_vector_after_write_le = init_container>( + 0x78, 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71); + for (typename std::vector::size_type i = kBits / 8; i < 8; ++i) { + expected_vector_after_write_le[i] = ByteT(i + 1); + } + + std::vector actual_vector_le; + for (auto it = write_container_le.begin(); it != write_container_le.end(); + ++it) { + actual_vector_le.push_back(*it); + } + EXPECT_EQ(expected_vector_after_write_le, actual_vector_le) + << "Write LE Failed. Mask = " << static_cast(partition_mask) + << "; kBits = " << kBits; + + auto write_container_be = container; + UnalignedAccessor::WriteBigEndianUInt( + write_container_be.begin(), 0x7172737475767778UL >> (64 - kBits)); + + auto expected_vector_after_write_be = init_container>( + 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78); + for (typename std::vector::size_type i = kBits / 8; i < 8; ++i) { + expected_vector_after_write_be[i] = ByteT(i + 1); + } + + std::vector actual_vector_be; + for (auto it = write_container_be.begin(); it != write_container_be.end(); + ++it) { + actual_vector_be.push_back(*it); + } + EXPECT_EQ(expected_vector_after_write_be, actual_vector_be) + << "Write BE Failed. Mask = " << static_cast(partition_mask) + << "; kBits = " << kBits; + } + + // Recursively iterate the template: + TestIteratorUnalignedAccessor(); +} + +template <> +void TestIteratorUnalignedAccessor() {} + +#if __cplusplus >= 201703L +template <> +void TestIteratorUnalignedAccessor() {} +#endif + +template <> +void TestIteratorUnalignedAccessor() {} + +TEST(UnalignedAccessor, IteratorReadsAndWrites) { + TestIteratorUnalignedAccessor(); +#if __cplusplus >= 201703L + TestIteratorUnalignedAccessor(); +#endif + TestIteratorUnalignedAccessor(); +} + +template +void TestIteratorStorage() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x11), ByteT(0x22)}, + {ByteT(0x33), ByteT(0x44), ByteT(0x55)}, + {ByteT(0x66), ByteT(0x77), ByteT(0x88)}}; + + NoncontiguousContainer container(chunks); + + IteratorStorage::iterator> storage( + container.begin(), container.end()); + + EXPECT_EQ(storage.SizeInBytes(), 8U); + + // Test full 64-bit Reads via UnalignedAccessor delegation + EXPECT_EQ(0x8877665544332211UL, storage.template ReadLittleEndianUInt<64>()); + EXPECT_EQ(0x1122334455667788UL, storage.template ReadBigEndianUInt<64>()); + + // Test sub-storage offsets + auto substorage1 = storage.template GetOffsetStorage<1, 0>(2, 4); + EXPECT_EQ(substorage1.SizeInBytes(), 4U); + EXPECT_EQ(0x66554433UL, substorage1.template ReadLittleEndianUInt<32>()); + + auto substorage2 = storage.template GetOffsetStorage<1, 0>( + 6, 4); // Out of bounds truncates size + EXPECT_EQ(substorage2.SizeInBytes(), 2U); + EXPECT_EQ(0x8877UL, substorage2.template ReadLittleEndianUInt<16>()); + + // Test 32-bit Writes + auto write_storage = storage.template GetOffsetStorage<1, 0>(0, 4); + write_storage.template WriteLittleEndianUInt<32>(0x99AABBCCUL); + + std::vector verify_le; + for (auto it = write_storage.begin(); it != write_storage.end(); ++it) { + verify_le.push_back(*it); + } + std::vector expected_le = {ByteT(0xCC), ByteT(0xBB), ByteT(0xAA), + ByteT(0x99)}; + EXPECT_EQ(verify_le, expected_le); + + write_storage.template WriteBigEndianUInt<32>(0x99AABBCCUL); + std::vector verify_be; + for (auto it = write_storage.begin(); it != write_storage.end(); ++it) { + verify_be.push_back(*it); + } + std::vector expected_be = {ByteT(0x99), ByteT(0xAA), ByteT(0xBB), + ByteT(0xCC)}; + EXPECT_EQ(verify_be, expected_be); + + // Test copy from + IteratorStorage::iterator> copy_dest = + storage.template GetOffsetStorage<1, 0>(0, 4); + copy_dest.CopyFrom(write_storage, 4); + std::vector verify_copy; + for (auto it = copy_dest.begin(); it != copy_dest.end(); ++it) { + verify_copy.push_back(*it); + } + EXPECT_EQ(verify_copy, expected_be); +} + +template +void TestIteratorBitBlock() { + using ByteT = typename std::remove_const::type; + + std::vector> chunks = { + {ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00)}, + {ByteT(0x00), ByteT(0x00), ByteT(0x00)}}; + NoncontiguousContainer container(chunks); + + IteratorStorage::iterator> storage( + container.begin(), container.end()); + + LittleEndianByteOrderer< + IteratorStorage::iterator>> + le_orderer(storage); + BitBlock le_block(le_orderer); + + EXPECT_TRUE(le_block.Ok()); + EXPECT_EQ(le_block.SizeInBits(), 64U); + + le_block.WriteUInt(0xAABBCCDDEEFF1122UL); + EXPECT_EQ(0xAABBCCDDEEFF1122UL, le_block.ReadUInt()); + + std::vector expect_le = {ByteT(0x22), ByteT(0x11), ByteT(0xFF), + ByteT(0xEE), ByteT(0xDD), ByteT(0xCC), + ByteT(0xBB), ByteT(0xAA)}; + std::vector verify_le; + for (auto it = storage.begin(); it != storage.end(); ++it) { + verify_le.push_back(*it); + } + EXPECT_EQ(expect_le, verify_le); + + BigEndianByteOrderer< + IteratorStorage::iterator>> + be_orderer(storage); + BitBlock be_block(be_orderer); + + be_block.WriteUInt(0x1122334455667788UL); + EXPECT_EQ(0x1122334455667788UL, be_block.ReadUInt()); + + std::vector expect_be = {ByteT(0x11), ByteT(0x22), ByteT(0x33), + ByteT(0x44), ByteT(0x55), ByteT(0x66), + ByteT(0x77), ByteT(0x88)}; + std::vector verify_be; + for (auto it = storage.begin(); it != storage.end(); ++it) { + verify_be.push_back(*it); + } + EXPECT_EQ(expect_be, verify_be); + + // Test Sub-Offsets + auto le_subblock = le_block.template GetOffsetStorage<1, 0>(16, 32); + EXPECT_EQ(le_subblock.SizeInBits(), 32U); + EXPECT_EQ(0x66554433UL, le_subblock.ReadUInt()); + + auto be_subblock = be_block.template GetOffsetStorage<1, 0>(16, 32); + EXPECT_EQ(be_subblock.SizeInBits(), 32U); + EXPECT_EQ(0x33445566UL, be_subblock.ReadUInt()); +} + +template +void TestCbeginCend() { + using ByteT = typename std::remove_const::type; + std::vector> chunks = {{ByteT(0x77)}}; + ::emboss::support::test::NoncontiguousContainer container(chunks); + + ::emboss::support::IteratorStorage storage( + container.cbegin(), container.cend()); + + // Confirm cbegin/cend are exposed and evaluatable for const character + // iterators: + auto cb = storage.cbegin(); + auto ce = storage.cend(); + EXPECT_TRUE(cb != ce); +} + +TEST(IteratorStorage, CbeginCend) { + TestCbeginCend(); + TestCbeginCend(); + TestCbeginCend(); + TestCbeginCend(); +#if __cplusplus >= 201703L + TestCbeginCend(); + TestCbeginCend(); +#endif +} + +TEST(IteratorStorage, ReadWriteOffsetting) { + TestIteratorStorage(); + TestIteratorStorage(); + TestIteratorStorage(); + TestIteratorStorage(); +#if __cplusplus >= 201703L + TestIteratorStorage(); + TestIteratorStorage(); +#endif +} + +TEST(BitBlock, IteratorStorageIntegration) { + TestIteratorBitBlock(); + TestIteratorBitBlock(); + TestIteratorBitBlock(); + TestIteratorBitBlock(); +#if __cplusplus >= 201703L + TestIteratorBitBlock(); + TestIteratorBitBlock(); +#endif +} + TEST(ContiguousBuffer, OffsetStorageType) { EXPECT_TRUE((::std::is_same< ContiguousBuffer, diff --git a/runtime/cpp/test/util/BUILD b/runtime/cpp/test/util/BUILD new file mode 100644 index 0000000..6f3857e --- /dev/null +++ b/runtime/cpp/test/util/BUILD @@ -0,0 +1,18 @@ +load("@rules_cc//cc:cc_library.bzl", "cc_library") +load("//runtime/cpp/test:build_defs.bzl", "emboss_cc_util_test") + +cc_library( + name = "noncontiguous_container", + hdrs = ["noncontiguous_container.h"], + visibility = ["//runtime/cpp/test:__pkg__", "//visibility:public"], +) + +emboss_cc_util_test( + name = "noncontiguous_container_test", + srcs = ["noncontiguous_container_test.cc"], + deps = [ + ":noncontiguous_container", + "//runtime/cpp:cpp_utils", + "@com_google_googletest//:gtest_main", + ], +) diff --git a/runtime/cpp/test/util/noncontiguous_container.h b/runtime/cpp/test/util/noncontiguous_container.h new file mode 100644 index 0000000..e9d2951 --- /dev/null +++ b/runtime/cpp/test/util/noncontiguous_container.h @@ -0,0 +1,275 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef EMBOSS_RUNTIME_CPP_TEST_UTIL_NONCONTIGUOUS_CONTAINER_H_ +#define EMBOSS_RUNTIME_CPP_TEST_UTIL_NONCONTIGUOUS_CONTAINER_H_ + +#include +#include +#include +#include +#include +#include + +namespace emboss { +namespace support { +namespace test { + +// A mock non-contiguous container representing data fragmented across a storage +// collection of individual chunks. +template class ChunkT = std::vector, + template class StorageT = std::vector> +class NoncontiguousContainer { + public: + using value_type = T; + using Chunk = ChunkT; + using Storage = StorageT; + using size_type = std::size_t; + + template + class IteratorBase { + public: + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = std::ptrdiff_t; + using pointer = typename std::conditional::type; + using reference = typename std::conditional::type; + + private: + using StoragePtr = + typename std::conditional::type; + using ChunkIterator = + typename std::conditional::type; + + IteratorBase(StoragePtr storage, size_type chunk_idx, + difference_type byte_idx, ChunkIterator chunk_it) + : storage_(storage), + chunk_idx_(chunk_idx), + byte_idx_(byte_idx), + chunk_it_(chunk_it) { + Normalize(); + } + + friend IteratorBase; + friend NoncontiguousContainer; + + public: + IteratorBase() = default; + + // Allow implicit conversion from non-const to const iterator + template ::type> + operator IteratorBase() const { + return IteratorBase(storage_, chunk_idx_, byte_idx_, chunk_it_); + } + + reference operator*() const { + auto element_it = chunk_it_->begin(); + std::advance(element_it, byte_idx_); + return *element_it; + } + + pointer operator->() const { return &(*(*this)); } + + reference operator[](difference_type n) const { return *(*this + n); } + + IteratorBase& operator++() { + ++byte_idx_; + Normalize(); + return *this; + } + + IteratorBase operator++(int) { + IteratorBase temp = *this; + ++(*this); + return temp; + } + + IteratorBase& operator--() { + --byte_idx_; + Normalize(); + return *this; + } + + IteratorBase operator--(int) { + IteratorBase temp = *this; + --(*this); + return temp; + } + + IteratorBase& operator+=(difference_type n) { + byte_idx_ += n; + Normalize(); + return *this; + } + + IteratorBase operator+(difference_type n) const { + IteratorBase temp = *this; + return temp += n; + } + + friend IteratorBase operator+(difference_type n, const IteratorBase& it) { + return it + n; + } + + IteratorBase& operator-=(difference_type n) { + byte_idx_ -= n; + Normalize(); + return *this; + } + + IteratorBase operator-(difference_type n) const { + IteratorBase temp = *this; + return temp -= n; + } + + template + difference_type operator-(const IteratorBase& other) const { + difference_type dist = 0; + IteratorBase temp = other; + + // If other is ahead of us, compute distance and negate + if (temp > *this) { + return -(temp - *this); + } + + while (temp != *this) { + size_type temp_remaining = temp.chunk_it_->size() - temp.byte_idx_; + + if (temp.chunk_idx_ == this->chunk_idx_) { + dist += (this->byte_idx_ - temp.byte_idx_); + break; + } else { + dist += temp_remaining; + ++temp.chunk_idx_; + ++temp.chunk_it_; + temp.byte_idx_ = 0; + temp.Normalize(); + } + } + return dist; + } + + template + bool operator==(const IteratorBase& other) const { + return storage_ == other.storage_ && chunk_idx_ == other.chunk_idx_ && + byte_idx_ == other.byte_idx_; + } + + template + bool operator!=(const IteratorBase& other) const { + return !(*this == other); + } + + template + bool operator<(const IteratorBase& other) const { + if (chunk_idx_ != other.chunk_idx_) return chunk_idx_ < other.chunk_idx_; + return byte_idx_ < other.byte_idx_; + } + + template + bool operator>(const IteratorBase& other) const { + return other < *this; + } + + template + bool operator<=(const IteratorBase& other) const { + return !(other < *this); + } + + template + bool operator>=(const IteratorBase& other) const { + return !(*this < other); + } + + private: + StoragePtr storage_ = nullptr; + size_type chunk_idx_ = 0; + difference_type byte_idx_ = 0; + ChunkIterator chunk_it_ = {}; + + void Normalize() { + if (!storage_) return; + + // Handle backward normalization + while (byte_idx_ < 0) { + if (chunk_idx_ == 0) { + // Invalid `byte_idx_`, but required for random_access_iterator. + return; + } + --chunk_idx_; + --chunk_it_; + byte_idx_ += static_cast(chunk_it_->size()); + } + + // Handle forward normalization + while (chunk_idx_ < storage_->size() && + byte_idx_ >= static_cast(chunk_it_->size())) { + byte_idx_ -= static_cast(chunk_it_->size()); + ++chunk_idx_; + ++chunk_it_; + } + } + }; + + using iterator = IteratorBase; + using const_iterator = IteratorBase; + + explicit NoncontiguousContainer(Storage chunks) : chunks_(std::move(chunks)) { + for (const auto& chunk : chunks_) { + total_size_ += chunk.size(); + } + } + + NoncontiguousContainer( + std::initializer_list init) + : chunks_(init) { + for (const auto& chunk : chunks_) { + total_size_ += chunk.size(); + } + } + + iterator begin() { return iterator(&chunks_, 0, 0, chunks_.begin()); } + iterator end() { + return iterator(&chunks_, chunks_.size(), 0, chunks_.end()); + } + + const_iterator begin() const { + return const_iterator(&chunks_, 0, 0, chunks_.begin()); + } + const_iterator end() const { + return const_iterator(&chunks_, chunks_.size(), 0, chunks_.end()); + } + + const_iterator cbegin() const { + return const_iterator(&chunks_, 0, 0, chunks_.begin()); + } + const_iterator cend() const { + return const_iterator(&chunks_, chunks_.size(), 0, chunks_.end()); + } + + size_type size() const { return total_size_; } + + private: + Storage chunks_; + size_type total_size_ = 0; +}; + +} // namespace test +} // namespace support +} // namespace emboss + +#endif // EMBOSS_RUNTIME_CPP_TEST_UTIL_NONCONTIGUOUS_CONTAINER_H_ diff --git a/runtime/cpp/test/util/noncontiguous_container_test.cc b/runtime/cpp/test/util/noncontiguous_container_test.cc new file mode 100644 index 0000000..0a010cb --- /dev/null +++ b/runtime/cpp/test/util/noncontiguous_container_test.cc @@ -0,0 +1,257 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "runtime/cpp/test/util/noncontiguous_container.h" + +#include +#include +#include +#include +#include + +#include "gtest/gtest.h" + +namespace emboss { +namespace support { +namespace test { +namespace { + +template +bool IsNoncontiguous(const Container& container) { + if (container.size() <= 1) return false; + auto it = container.begin(); + auto prev = it++; + for (; it != container.end(); ++it, ++prev) { + if (std::addressof(*it) != std::addressof(*prev) + 1) { + return true; + } + } + return false; +} + +TEST(NoncontiguousContainer, BasicStringChunkIteration) { + NoncontiguousContainer container( + {"12", "", "3", "456"}); + EXPECT_TRUE(IsNoncontiguous(container)); + + std::string result; + for (auto it = container.cbegin(); it != container.cend(); ++it) { + result += *it; + } + EXPECT_EQ("123456", result); +} + +TEST(NoncontiguousContainer, GenericVectorIteration) { + NoncontiguousContainer container({{1, 2}, {}, {3}, {4, 5, 6}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + int sum = 0; + for (int v : container) { + sum += v; + } + EXPECT_EQ(21, sum); +} + +TEST(NoncontiguousContainer, StdListStorageIteration) { + NoncontiguousContainer container( + {{10, 20}, {30}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + int sum = 0; + for (int v : container) { + sum += v; + } + EXPECT_EQ(60, sum); +} + +TEST(NoncontiguousContainer, RandomAccessAdvance) { + NoncontiguousContainer container({{'1', '2'}, {'3'}, {'4', '5', '6'}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + auto it = container.begin(); + EXPECT_EQ('1', *it); + + it += 2; + EXPECT_EQ('3', *it); + + it += 3; + EXPECT_EQ('6', *it); + + it -= 4; + EXPECT_EQ('2', *it); +} + +TEST(NoncontiguousContainer, DistanceOperator) { + NoncontiguousContainer container( + {{'a', 'b', 'c'}, {'d', 'e', 'f'}, {'g', 'h', 'i'}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + auto begin = container.begin(); + auto end = container.end(); + + EXPECT_EQ(9, end - begin); + EXPECT_EQ(-9, begin - end); + + auto mid = begin + 4; + EXPECT_EQ('e', *mid); + EXPECT_EQ(4, mid - begin); + EXPECT_EQ(-4, begin - mid); + EXPECT_EQ(5, end - mid); + EXPECT_EQ(-5, mid - end); +} + +TEST(NoncontiguousContainer, RelationalOperators) { + NoncontiguousContainer container({{1, 2}, {3, 4}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + auto it1 = container.begin(); + auto it2 = container.begin() + 1; + auto it3 = container.begin() + 2; + + EXPECT_TRUE(it1 == it1); + EXPECT_TRUE(it1 != it2); + + EXPECT_TRUE(it1 < it2); + EXPECT_TRUE(it2 > it1); + EXPECT_TRUE(it1 <= it2); + EXPECT_TRUE(it1 <= it1); + EXPECT_TRUE(it2 >= it1); + EXPECT_TRUE(it2 >= it2); + + EXPECT_TRUE(it1 < it3); + EXPECT_TRUE(it2 < it3); +} + +TEST(NoncontiguousContainer, DecrementFromEnd) { + NoncontiguousContainer container({{1, 2}, {3}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + auto it = container.end(); + --it; + EXPECT_EQ(3, *it); + it -= 2; + EXPECT_EQ(1, *it); +} + +TEST(NoncontiguousContainer, ContiguousOrEmpty) { + NoncontiguousContainer empty({}); + EXPECT_EQ(empty.begin(), empty.end()); + EXPECT_EQ(0U, empty.size()); + + NoncontiguousContainer single({{42}}); + EXPECT_FALSE(IsNoncontiguous(single)); + EXPECT_EQ(1U, single.size()); + EXPECT_EQ(42, *single.begin()); + + auto it = single.begin(); + ++it; + EXPECT_EQ(it, single.end()); + + NoncontiguousContainer contiguous({{1, 2, 3, 4, 5}}); + EXPECT_FALSE(IsNoncontiguous(contiguous)); + EXPECT_EQ(5U, contiguous.size()); + + int sum = 0; + for (int v : contiguous) { + sum += v; + } + EXPECT_EQ(15, sum); +} + +TEST(NoncontiguousContainer, StdCopyAcrossChunks) { + NoncontiguousContainer container({{'a', 'b'}, {'c', 'd'}, {'e', 'f'}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + { + std::string dest = " "; + auto start = container.begin() + 1; + auto dest_it = dest.begin(); + for (int i = 0; i < 4; ++i) { + *dest_it++ = *start++; + } + EXPECT_EQ("bcde", dest); + } + + { + std::string dest; + dest.resize(3); + std::copy_n(container.begin(), 3, dest.begin()); + EXPECT_EQ("abc", dest); + } + + { + std::string dest; + std::copy(container.begin() + 2, container.end(), std::back_inserter(dest)); + EXPECT_EQ("cdef", dest); + } + + { + std::string dest; + std::copy(container.begin(), container.end(), std::back_inserter(dest)); + EXPECT_EQ("abcdef", dest); + } + + { + std::string src = "123456"; + std::copy(src.begin(), src.end(), container.begin()); + + std::string dest; + std::copy(container.begin(), container.end(), std::back_inserter(dest)); + EXPECT_EQ(src, dest); + } +} + +TEST(NoncontiguousContainer, ConsecutiveEmptyChunks) { + NoncontiguousContainer container({{'a'}, {}, {}, {'b'}, {}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + auto begin = container.begin(); + auto end = container.end(); + + EXPECT_EQ(2, end - begin); + EXPECT_EQ('a', *begin); + + auto second = begin + 1; + EXPECT_EQ('b', *second); + + auto after_second = second + 1; + EXPECT_TRUE(after_second == end); +} + +TEST(NoncontiguousContainer, IteratorTraitsAndConstValidation) { + using ContainerT = NoncontiguousContainer; + + using CatT = typename ContainerT::iterator::iterator_category; + using IsRandomCat = std::is_same; + EXPECT_TRUE(IsRandomCat::value); + + using ValT = typename ContainerT::iterator::value_type; + using IsIntVal = std::is_same; + EXPECT_TRUE(IsIntVal::value); + + const ContainerT container({{1}, {2, 3}}); + EXPECT_TRUE(IsNoncontiguous(container)); + + int sum = 0; + for (ContainerT::const_iterator it = container.cbegin(); + it != container.cend(); ++it) { + sum += *it; + } + EXPECT_EQ(6, sum); +} + +} // namespace +} // namespace test +} // namespace support +} // namespace emboss diff --git a/testdata/golden_cpp/alignments.emb.h b/testdata/golden_cpp/alignments.emb.h index e60daf5..fd951d6 100644 --- a/testdata/golden_cpp/alignments.emb.h +++ b/testdata/golden_cpp/alignments.emb.h @@ -1281,6 +1281,40 @@ MakeAlignedAlignmentsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAlignmentsView< + /**/ ::emboss::support::IteratorStorage> +MakeAlignmentsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAlignmentsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAlignmentsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAlignmentsView( Container &&emboss_reserved_local_container) { + return GenericAlignmentsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Placeholder4 { @@ -1699,6 +1733,40 @@ MakeAlignedPlaceholder4View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericPlaceholder4View< + /**/ ::emboss::support::IteratorStorage> +MakePlaceholder4View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericPlaceholder4View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericPlaceholder4View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakePlaceholder4View( Container &&emboss_reserved_local_container) { + return GenericPlaceholder4View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2195,6 +2263,40 @@ MakeAlignedPlaceholder6View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericPlaceholder6View< + /**/ ::emboss::support::IteratorStorage> +MakePlaceholder6View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericPlaceholder6View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericPlaceholder6View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakePlaceholder6View( Container &&emboss_reserved_local_container) { + return GenericPlaceholder6View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Alignments { } // namespace Alignments diff --git a/testdata/golden_cpp/anonymous_bits.emb.h b/testdata/golden_cpp/anonymous_bits.emb.h index 7d505c9..49aaf34 100644 --- a/testdata/golden_cpp/anonymous_bits.emb.h +++ b/testdata/golden_cpp/anonymous_bits.emb.h @@ -646,6 +646,40 @@ MakeAlignedEmbossReservedAnonymousField2View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField2View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField2View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + enum class Bar : ::std::uint64_t { BAR = static_cast(0LL), BAZ = static_cast(1LL), @@ -1235,6 +1269,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace Foo @@ -1895,6 +1963,40 @@ MakeAlignedFooView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericFooView< + /**/ ::emboss::support::IteratorStorage> +MakeFooView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericFooView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericFooView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeFooView( Container &&emboss_reserved_local_container) { + return GenericFooView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Foo { namespace EmbossReservedAnonymousField2 { diff --git a/testdata/golden_cpp/auto_array_size.emb.h b/testdata/golden_cpp/auto_array_size.emb.h index 64e2973..b54c5a2 100644 --- a/testdata/golden_cpp/auto_array_size.emb.h +++ b/testdata/golden_cpp/auto_array_size.emb.h @@ -541,6 +541,40 @@ MakeAlignedElementView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericElementView< + /**/ ::emboss::support::IteratorStorage> +MakeElementView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericElementView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeElementView( Container &&emboss_reserved_local_container) { + return GenericElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1332,6 +1366,40 @@ MakeAlignedAutoSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAutoSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeAutoSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAutoSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAutoSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAutoSizeView( Container &&emboss_reserved_local_container) { + return GenericAutoSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Element { } // namespace Element diff --git a/testdata/golden_cpp/bcd.emb.h b/testdata/golden_cpp/bcd.emb.h index 1e4edc2..9e75392 100644 --- a/testdata/golden_cpp/bcd.emb.h +++ b/testdata/golden_cpp/bcd.emb.h @@ -729,6 +729,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace BcdSizes @@ -1947,6 +1981,40 @@ MakeAlignedBcdSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBcdSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeBcdSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBcdSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBcdSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBcdSizesView( Container &&emboss_reserved_local_container) { + return GenericBcdSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace BcdBigEndian { @@ -2365,6 +2433,40 @@ MakeAlignedBcdBigEndianView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBcdBigEndianView< + /**/ ::emboss::support::IteratorStorage> +MakeBcdBigEndianView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBcdBigEndianView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBcdBigEndianView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBcdBigEndianView( Container &&emboss_reserved_local_container) { + return GenericBcdBigEndianView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace BcdSizes { namespace EmbossReservedAnonymousField1 { diff --git a/testdata/golden_cpp/bits.emb.h b/testdata/golden_cpp/bits.emb.h index e6f29da..ab1eca4 100644 --- a/testdata/golden_cpp/bits.emb.h +++ b/testdata/golden_cpp/bits.emb.h @@ -827,6 +827,40 @@ MakeAlignedOneByteView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOneByteView< + /**/ ::emboss::support::IteratorStorage> +MakeOneByteView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOneByteView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOneByteView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOneByteView( Container &&emboss_reserved_local_container) { + return GenericOneByteView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace FourByte { @@ -1430,6 +1464,40 @@ MakeAlignedTwoByteWithGapsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericTwoByteWithGapsView< + /**/ ::emboss::support::IteratorStorage> +MakeTwoByteWithGapsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericTwoByteWithGapsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericTwoByteWithGapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeTwoByteWithGapsView( Container &&emboss_reserved_local_container) { + return GenericTwoByteWithGapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace FourByte @@ -2216,6 +2284,40 @@ MakeAlignedFourByteView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericFourByteView< + /**/ ::emboss::support::IteratorStorage> +MakeFourByteView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericFourByteView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericFourByteView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeFourByteView( Container &&emboss_reserved_local_container) { + return GenericFourByteView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2720,6 +2822,40 @@ MakeAlignedArrayInBitsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericArrayInBitsView< + /**/ ::emboss::support::IteratorStorage> +MakeArrayInBitsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericArrayInBitsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericArrayInBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeArrayInBitsView( Container &&emboss_reserved_local_container) { + return GenericArrayInBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace ArrayInBitsInStruct { @@ -3136,6 +3272,40 @@ MakeAlignedArrayInBitsInStructView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericArrayInBitsInStructView< + /**/ ::emboss::support::IteratorStorage> +MakeArrayInBitsInStructView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericArrayInBitsInStructView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericArrayInBitsInStructView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeArrayInBitsInStructView( Container &&emboss_reserved_local_container) { + return GenericArrayInBitsInStructView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3824,6 +3994,40 @@ MakeAlignedStructOfBitsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructOfBitsView< + /**/ ::emboss::support::IteratorStorage> +MakeStructOfBitsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructOfBitsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructOfBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructOfBitsView( Container &&emboss_reserved_local_container) { + return GenericStructOfBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace BitArray { @@ -4244,6 +4448,40 @@ MakeAlignedBitArrayView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBitArrayView< + /**/ ::emboss::support::IteratorStorage> +MakeBitArrayView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBitArrayView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBitArrayView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBitArrayView( Container &&emboss_reserved_local_container) { + return GenericBitArrayView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace OneByte { } // namespace OneByte diff --git a/testdata/golden_cpp/complex_offset.emb.h b/testdata/golden_cpp/complex_offset.emb.h index 31889b0..6d015c6 100644 --- a/testdata/golden_cpp/complex_offset.emb.h +++ b/testdata/golden_cpp/complex_offset.emb.h @@ -467,6 +467,40 @@ MakeAlignedLengthView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericLengthView< + /**/ ::emboss::support::IteratorStorage> +MakeLengthView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericLengthView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericLengthView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeLengthView( Container &&emboss_reserved_local_container) { + return GenericLengthView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -999,6 +1033,40 @@ MakeAlignedDataView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericDataView< + /**/ ::emboss::support::IteratorStorage> +MakeDataView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericDataView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericDataView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeDataView( Container &&emboss_reserved_local_container) { + return GenericDataView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2818,6 +2886,40 @@ MakeAlignedPackedFieldsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericPackedFieldsView< + /**/ ::emboss::support::IteratorStorage> +MakePackedFieldsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericPackedFieldsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericPackedFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakePackedFieldsView( Container &&emboss_reserved_local_container) { + return GenericPackedFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Length { } // namespace Length diff --git a/testdata/golden_cpp/complex_structure.emb.h b/testdata/golden_cpp/complex_structure.emb.h index 745976a..8801b9d 100644 --- a/testdata/golden_cpp/complex_structure.emb.h +++ b/testdata/golden_cpp/complex_structure.emb.h @@ -638,6 +638,40 @@ MakeAlignedRegisterLayoutView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRegisterLayoutView< + /**/ ::emboss::support::IteratorStorage> +MakeRegisterLayoutView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRegisterLayoutView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRegisterLayoutView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRegisterLayoutView( Container &&emboss_reserved_local_container) { + return GenericRegisterLayoutView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace ArrayElement { @@ -1054,6 +1088,40 @@ MakeAlignedArrayElementView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericArrayElementView< + /**/ ::emboss::support::IteratorStorage> +MakeArrayElementView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericArrayElementView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericArrayElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeArrayElementView( Container &&emboss_reserved_local_container) { + return GenericArrayElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1738,6 +1806,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace Complex @@ -3342,6 +3444,40 @@ MakeAlignedComplexView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericComplexView< + /**/ ::emboss::support::IteratorStorage> +MakeComplexView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericComplexView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericComplexView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeComplexView( Container &&emboss_reserved_local_container) { + return GenericComplexView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace RegisterLayout { } // namespace RegisterLayout diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 9d11fb7..7119e0d 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -832,6 +832,40 @@ MakeAlignedBasicConditionalView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBasicConditionalView< + /**/ ::emboss::support::IteratorStorage> +MakeBasicConditionalView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBasicConditionalView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBasicConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBasicConditionalView( Container &&emboss_reserved_local_container) { + return GenericBasicConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1362,6 +1396,40 @@ MakeAlignedNegativeConditionalView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNegativeConditionalView< + /**/ ::emboss::support::IteratorStorage> +MakeNegativeConditionalView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNegativeConditionalView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNegativeConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNegativeConditionalView( Container &&emboss_reserved_local_container) { + return GenericNegativeConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1944,6 +2012,40 @@ MakeAlignedConditionalAndUnconditionalOverlappingFinalFieldView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalAndUnconditionalOverlappingFinalFieldView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalAndUnconditionalOverlappingFinalFieldView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalAndUnconditionalOverlappingFinalFieldView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalAndUnconditionalOverlappingFinalFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalAndUnconditionalOverlappingFinalFieldView( Container &&emboss_reserved_local_container) { + return GenericConditionalAndUnconditionalOverlappingFinalFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2444,6 +2546,40 @@ MakeAlignedConditionalBasicConditionalFieldFirstView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalBasicConditionalFieldFirstView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalBasicConditionalFieldFirstView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalBasicConditionalFieldFirstView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalBasicConditionalFieldFirstView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalBasicConditionalFieldFirstView( Container &&emboss_reserved_local_container) { + return GenericConditionalBasicConditionalFieldFirstView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3059,6 +3195,40 @@ MakeAlignedConditionalAndDynamicLocationView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalAndDynamicLocationView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalAndDynamicLocationView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalAndDynamicLocationView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalAndDynamicLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalAndDynamicLocationView( Container &&emboss_reserved_local_container) { + return GenericConditionalAndDynamicLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3590,6 +3760,40 @@ MakeAlignedConditionUsesMinIntView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionUsesMinIntView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionUsesMinIntView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionUsesMinIntView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionUsesMinIntView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionUsesMinIntView( Container &&emboss_reserved_local_container) { + return GenericConditionUsesMinIntView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4206,6 +4410,40 @@ MakeAlignedNestedConditionalView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNestedConditionalView< + /**/ ::emboss::support::IteratorStorage> +MakeNestedConditionalView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNestedConditionalView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNestedConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNestedConditionalView( Container &&emboss_reserved_local_container) { + return GenericNestedConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4823,6 +5061,40 @@ MakeAlignedCorrectNestedConditionalView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericCorrectNestedConditionalView< + /**/ ::emboss::support::IteratorStorage> +MakeCorrectNestedConditionalView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericCorrectNestedConditionalView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericCorrectNestedConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeCorrectNestedConditionalView( Container &&emboss_reserved_local_container) { + return GenericCorrectNestedConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -5323,6 +5595,40 @@ MakeAlignedAlwaysFalseConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeAlwaysFalseConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAlwaysFalseConditionView( Container &&emboss_reserved_local_container) { + return GenericAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace OnlyAlwaysFalseCondition { @@ -5741,6 +6047,40 @@ MakeAlignedOnlyAlwaysFalseConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOnlyAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeOnlyAlwaysFalseConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOnlyAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOnlyAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOnlyAlwaysFalseConditionView( Container &&emboss_reserved_local_container) { + return GenericOnlyAlwaysFalseConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace EmptyStruct { @@ -6081,6 +6421,40 @@ MakeAlignedEmptyStructView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmptyStructView< + /**/ ::emboss::support::IteratorStorage> +MakeEmptyStructView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmptyStructView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmptyStructView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmptyStructView( Container &&emboss_reserved_local_container) { + return GenericEmptyStructView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6693,6 +7067,40 @@ MakeAlignedAlwaysFalseConditionDynamicSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAlwaysFalseConditionDynamicSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeAlwaysFalseConditionDynamicSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAlwaysFalseConditionDynamicSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAlwaysFalseConditionDynamicSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAlwaysFalseConditionDynamicSizeView( Container &&emboss_reserved_local_container) { + return GenericAlwaysFalseConditionDynamicSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7274,6 +7682,40 @@ MakeAlignedConditionDoesNotContributeToSizeView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericConditionDoesNotContributeToSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionDoesNotContributeToSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionDoesNotContributeToSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionDoesNotContributeToSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionDoesNotContributeToSizeView( Container &&emboss_reserved_local_container) { + return GenericConditionDoesNotContributeToSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class OnOff : ::std::uint64_t { OFF = static_cast(0LL), ON = static_cast(1LL), @@ -7977,6 +8419,40 @@ MakeAlignedEnumConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEnumConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeEnumConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEnumConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEnumConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEnumConditionView( Container &&emboss_reserved_local_container) { + return GenericEnumConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -8508,6 +8984,40 @@ MakeAlignedNegativeEnumConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNegativeEnumConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeNegativeEnumConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNegativeEnumConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNegativeEnumConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNegativeEnumConditionView( Container &&emboss_reserved_local_container) { + return GenericNegativeEnumConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -9038,6 +9548,40 @@ MakeAlignedLessThanConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericLessThanConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeLessThanConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericLessThanConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericLessThanConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeLessThanConditionView( Container &&emboss_reserved_local_container) { + return GenericLessThanConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -9568,6 +10112,40 @@ MakeAlignedLessThanOrEqualConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericLessThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeLessThanOrEqualConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericLessThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericLessThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeLessThanOrEqualConditionView( Container &&emboss_reserved_local_container) { + return GenericLessThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -10098,6 +10676,40 @@ MakeAlignedGreaterThanOrEqualConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericGreaterThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeGreaterThanOrEqualConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericGreaterThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericGreaterThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeGreaterThanOrEqualConditionView( Container &&emboss_reserved_local_container) { + return GenericGreaterThanOrEqualConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -10628,6 +11240,40 @@ MakeAlignedGreaterThanConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericGreaterThanConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeGreaterThanConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericGreaterThanConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericGreaterThanConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeGreaterThanConditionView( Container &&emboss_reserved_local_container) { + return GenericGreaterThanConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -11246,6 +11892,40 @@ MakeAlignedRangeConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRangeConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeRangeConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRangeConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRangeConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRangeConditionView( Container &&emboss_reserved_local_container) { + return GenericRangeConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -11864,6 +12544,40 @@ MakeAlignedReverseRangeConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericReverseRangeConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeReverseRangeConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericReverseRangeConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericReverseRangeConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeReverseRangeConditionView( Container &&emboss_reserved_local_container) { + return GenericReverseRangeConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -12480,6 +13194,40 @@ MakeAlignedAndConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAndConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeAndConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAndConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAndConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAndConditionView( Container &&emboss_reserved_local_container) { + return GenericAndConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -13096,6 +13844,40 @@ MakeAlignedOrConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOrConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeOrConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOrConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOrConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOrConditionView( Container &&emboss_reserved_local_container) { + return GenericOrConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -13884,6 +14666,40 @@ MakeAlignedChoiceConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericChoiceConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeChoiceConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericChoiceConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericChoiceConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeChoiceConditionView( Container &&emboss_reserved_local_container) { + return GenericChoiceConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -14390,6 +15206,40 @@ MakeAlignedEmbossReservedAnonymousField3View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField3View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField3View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField3View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField3View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField3View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField3View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ContainsBits @@ -14862,6 +15712,40 @@ MakeAlignedContainsBitsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericContainsBitsView< + /**/ ::emboss::support::IteratorStorage> +MakeContainsBitsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericContainsBitsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericContainsBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeContainsBitsView( Container &&emboss_reserved_local_container) { + return GenericContainsBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -15390,6 +16274,40 @@ MakeAlignedContainsContainsBitsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericContainsContainsBitsView< + /**/ ::emboss::support::IteratorStorage> +MakeContainsContainsBitsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericContainsContainsBitsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericContainsContainsBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeContainsContainsBitsView( Container &&emboss_reserved_local_container) { + return GenericContainsContainsBitsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -15978,6 +16896,40 @@ MakeAlignedType0View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericType0View< + /**/ ::emboss::support::IteratorStorage> +MakeType0View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericType0View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericType0View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeType0View( Container &&emboss_reserved_local_container) { + return GenericType0View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -16561,6 +17513,40 @@ MakeAlignedType1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericType1View< + /**/ ::emboss::support::IteratorStorage> +MakeType1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericType1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericType1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeType1View( Container &&emboss_reserved_local_container) { + return GenericType1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ConditionalInline @@ -17165,6 +18151,40 @@ MakeAlignedConditionalInlineView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalInlineView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalInlineView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalInlineView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalInlineView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalInlineView( Container &&emboss_reserved_local_container) { + return GenericConditionalInlineView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -17755,6 +18775,40 @@ MakeAlignedEmbossReservedAnonymousField2View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField2View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField2View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ConditionalAnonymous @@ -18387,6 +19441,40 @@ MakeAlignedConditionalAnonymousView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalAnonymousView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalAnonymousView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalAnonymousView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalAnonymousView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalAnonymousView( Container &&emboss_reserved_local_container) { + return GenericConditionalAnonymousView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -18811,6 +19899,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ConditionalOnFlag @@ -19344,6 +20466,40 @@ MakeAlignedConditionalOnFlagView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConditionalOnFlagView< + /**/ ::emboss::support::IteratorStorage> +MakeConditionalOnFlagView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConditionalOnFlagView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConditionalOnFlagView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConditionalOnFlagView( Container &&emboss_reserved_local_container) { + return GenericConditionalOnFlagView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace BasicConditional { } // namespace BasicConditional diff --git a/testdata/golden_cpp/dynamic_size.emb.h b/testdata/golden_cpp/dynamic_size.emb.h index 8c5f5b5..35038b0 100644 --- a/testdata/golden_cpp/dynamic_size.emb.h +++ b/testdata/golden_cpp/dynamic_size.emb.h @@ -904,6 +904,40 @@ MakeAlignedMessageView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericMessageView< + /**/ ::emboss::support::IteratorStorage> +MakeMessageView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericMessageView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericMessageView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeMessageView( Container &&emboss_reserved_local_container) { + return GenericMessageView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1447,6 +1481,40 @@ MakeAlignedImageView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericImageView< + /**/ ::emboss::support::IteratorStorage> +MakeImageView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericImageView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericImageView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeImageView( Container &&emboss_reserved_local_container) { + return GenericImageView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2322,6 +2390,40 @@ MakeAlignedTwoRegionsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericTwoRegionsView< + /**/ ::emboss::support::IteratorStorage> +MakeTwoRegionsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericTwoRegionsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericTwoRegionsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeTwoRegionsView( Container &&emboss_reserved_local_container) { + return GenericTwoRegionsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2941,6 +3043,40 @@ MakeAlignedMultipliedSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericMultipliedSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeMultipliedSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericMultipliedSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericMultipliedSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeMultipliedSizeView( Container &&emboss_reserved_local_container) { + return GenericMultipliedSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4096,6 +4232,40 @@ MakeAlignedNegativeTermsInSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNegativeTermsInSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeNegativeTermsInSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNegativeTermsInSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNegativeTermsInSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNegativeTermsInSizesView( Container &&emboss_reserved_local_container) { + return GenericNegativeTermsInSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4627,6 +4797,40 @@ MakeAlignedNegativeTermInLocationView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNegativeTermInLocationView< + /**/ ::emboss::support::IteratorStorage> +MakeNegativeTermInLocationView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNegativeTermInLocationView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNegativeTermInLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNegativeTermInLocationView( Container &&emboss_reserved_local_container) { + return GenericNegativeTermInLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -5329,6 +5533,40 @@ MakeAlignedChainedSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericChainedSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeChainedSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericChainedSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericChainedSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeChainedSizeView( Container &&emboss_reserved_local_container) { + return GenericChainedSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -5911,6 +6149,40 @@ MakeAlignedFinalFieldOverlapsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage> +MakeFinalFieldOverlapsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeFinalFieldOverlapsView( Container &&emboss_reserved_local_container) { + return GenericFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6608,6 +6880,40 @@ MakeAlignedDynamicFinalFieldOverlapsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericDynamicFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage> +MakeDynamicFinalFieldOverlapsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericDynamicFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericDynamicFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeDynamicFinalFieldOverlapsView( Container &&emboss_reserved_local_container) { + return GenericDynamicFinalFieldOverlapsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7139,6 +7445,40 @@ MakeAlignedDynamicFieldDependsOnLaterFieldView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericDynamicFieldDependsOnLaterFieldView< + /**/ ::emboss::support::IteratorStorage> +MakeDynamicFieldDependsOnLaterFieldView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericDynamicFieldDependsOnLaterFieldView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericDynamicFieldDependsOnLaterFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeDynamicFieldDependsOnLaterFieldView( Container &&emboss_reserved_local_container) { + return GenericDynamicFieldDependsOnLaterFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7721,6 +8061,40 @@ MakeAlignedDynamicFieldDoesNotAffectSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericDynamicFieldDoesNotAffectSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeDynamicFieldDoesNotAffectSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericDynamicFieldDoesNotAffectSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericDynamicFieldDoesNotAffectSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeDynamicFieldDoesNotAffectSizeView( Container &&emboss_reserved_local_container) { + return GenericDynamicFieldDoesNotAffectSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Message { } // namespace Message diff --git a/testdata/golden_cpp/enum.emb.h b/testdata/golden_cpp/enum.emb.h index f056862..7959a0b 100644 --- a/testdata/golden_cpp/enum.emb.h +++ b/testdata/golden_cpp/enum.emb.h @@ -537,6 +537,40 @@ MakeAlignedConstantsView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericConstantsView< + /**/ ::emboss::support::IteratorStorage> +MakeConstantsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConstantsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConstantsView( Container &&emboss_reserved_local_container) { + return GenericConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class Kind : ::std::uint64_t { WIDGET = static_cast(0LL), SPROCKET = static_cast(1LL), @@ -1908,6 +1942,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ManifestEntry @@ -2576,6 +2644,40 @@ MakeAlignedManifestEntryView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericManifestEntryView< + /**/ ::emboss::support::IteratorStorage> +MakeManifestEntryView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericManifestEntryView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericManifestEntryView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeManifestEntryView( Container &&emboss_reserved_local_container) { + return GenericManifestEntryView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace StructContainingEnum { @@ -3081,6 +3183,40 @@ MakeAlignedStructContainingEnumView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructContainingEnumView< + /**/ ::emboss::support::IteratorStorage> +MakeStructContainingEnumView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructContainingEnumView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructContainingEnumView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructContainingEnumView( Container &&emboss_reserved_local_container) { + return GenericStructContainingEnumView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Constants { } // namespace Constants diff --git a/testdata/golden_cpp/enum_case.emb.h b/testdata/golden_cpp/enum_case.emb.h index 5738596..f677c32 100644 --- a/testdata/golden_cpp/enum_case.emb.h +++ b/testdata/golden_cpp/enum_case.emb.h @@ -840,6 +840,40 @@ MakeAlignedUseKCamelEnumCaseView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericUseKCamelEnumCaseView< + /**/ ::emboss::support::IteratorStorage> +MakeUseKCamelEnumCaseView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericUseKCamelEnumCaseView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericUseKCamelEnumCaseView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeUseKCamelEnumCaseView( Container &&emboss_reserved_local_container) { + return GenericUseKCamelEnumCaseView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class EnumShoutyAndKCamel : ::std::uint64_t { FIRST = static_cast(0LL), kFirst = static_cast(0LL), diff --git a/testdata/golden_cpp/explicit_sizes.emb.h b/testdata/golden_cpp/explicit_sizes.emb.h index f8fd46f..87e49a3 100644 --- a/testdata/golden_cpp/explicit_sizes.emb.h +++ b/testdata/golden_cpp/explicit_sizes.emb.h @@ -653,6 +653,40 @@ MakeAlignedSizedUIntArraysView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizedUIntArraysView< + /**/ ::emboss::support::IteratorStorage> +MakeSizedUIntArraysView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizedUIntArraysView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizedUIntArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizedUIntArraysView( Container &&emboss_reserved_local_container) { + return GenericSizedUIntArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1247,6 +1281,40 @@ MakeAlignedSizedIntArraysView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizedIntArraysView< + /**/ ::emboss::support::IteratorStorage> +MakeSizedIntArraysView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizedIntArraysView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizedIntArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizedIntArraysView( Container &&emboss_reserved_local_container) { + return GenericSizedIntArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1844,6 +1912,40 @@ MakeAlignedSizedEnumArraysView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizedEnumArraysView< + /**/ ::emboss::support::IteratorStorage> +MakeSizedEnumArraysView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizedEnumArraysView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizedEnumArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizedEnumArraysView( Container &&emboss_reserved_local_container) { + return GenericSizedEnumArraysView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace BitArrayContainer { @@ -2259,6 +2361,40 @@ MakeAlignedBitArrayContainerView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericBitArrayContainerView< + /**/ ::emboss::support::IteratorStorage> +MakeBitArrayContainerView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBitArrayContainerView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBitArrayContainerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBitArrayContainerView( Container &&emboss_reserved_local_container) { + return GenericBitArrayContainerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class Enum : ::std::uint64_t { VALUE1 = static_cast(1LL), VALUE10 = static_cast(10LL), diff --git a/testdata/golden_cpp/float.emb.h b/testdata/golden_cpp/float.emb.h index d43d32e..4802ac6 100644 --- a/testdata/golden_cpp/float.emb.h +++ b/testdata/golden_cpp/float.emb.h @@ -541,6 +541,40 @@ MakeAlignedFloatsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericFloatsView< + /**/ ::emboss::support::IteratorStorage> +MakeFloatsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericFloatsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericFloatsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeFloatsView( Container &&emboss_reserved_local_container) { + return GenericFloatsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1041,6 +1075,40 @@ MakeAlignedDoublesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericDoublesView< + /**/ ::emboss::support::IteratorStorage> +MakeDoublesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericDoublesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericDoublesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeDoublesView( Container &&emboss_reserved_local_container) { + return GenericDoublesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Floats { } // namespace Floats diff --git a/testdata/golden_cpp/imported.emb.h b/testdata/golden_cpp/imported.emb.h index 2217543..0d16161 100644 --- a/testdata/golden_cpp/imported.emb.h +++ b/testdata/golden_cpp/imported.emb.h @@ -451,6 +451,40 @@ MakeAlignedInnerView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericInnerView< + /**/ ::emboss::support::IteratorStorage> +MakeInnerView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericInnerView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericInnerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeInnerView( Container &&emboss_reserved_local_container) { + return GenericInnerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Inner { } // namespace Inner diff --git a/testdata/golden_cpp/imported_genfiles.emb.h b/testdata/golden_cpp/imported_genfiles.emb.h index af1ef31..7f602e0 100644 --- a/testdata/golden_cpp/imported_genfiles.emb.h +++ b/testdata/golden_cpp/imported_genfiles.emb.h @@ -452,6 +452,40 @@ MakeAlignedInnerView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericInnerView< + /**/ ::emboss::support::IteratorStorage> +MakeInnerView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericInnerView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericInnerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeInnerView( Container &&emboss_reserved_local_container) { + return GenericInnerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Inner { } // namespace Inner diff --git a/testdata/golden_cpp/importer.emb.h b/testdata/golden_cpp/importer.emb.h index 75ad2d2..0aeed89 100644 --- a/testdata/golden_cpp/importer.emb.h +++ b/testdata/golden_cpp/importer.emb.h @@ -533,6 +533,40 @@ MakeAlignedOuterView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOuterView< + /**/ ::emboss::support::IteratorStorage> +MakeOuterView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOuterView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOuterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOuterView( Container &&emboss_reserved_local_container) { + return GenericOuterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Outer { } // namespace Outer diff --git a/testdata/golden_cpp/importer2.emb.h b/testdata/golden_cpp/importer2.emb.h index ca22c93..9f1eae0 100644 --- a/testdata/golden_cpp/importer2.emb.h +++ b/testdata/golden_cpp/importer2.emb.h @@ -451,6 +451,40 @@ MakeAlignedOuter2View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOuter2View< + /**/ ::emboss::support::IteratorStorage> +MakeOuter2View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOuter2View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOuter2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOuter2View( Container &&emboss_reserved_local_container) { + return GenericOuter2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Outer2 { } // namespace Outer2 diff --git a/testdata/golden_cpp/inline_type.emb.h b/testdata/golden_cpp/inline_type.emb.h index 8f89827..49ad7b7 100644 --- a/testdata/golden_cpp/inline_type.emb.h +++ b/testdata/golden_cpp/inline_type.emb.h @@ -716,6 +716,40 @@ MakeAlignedFooView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericFooView< + /**/ ::emboss::support::IteratorStorage> +MakeFooView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericFooView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericFooView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeFooView( Container &&emboss_reserved_local_container) { + return GenericFooView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Foo { diff --git a/testdata/golden_cpp/int_sizes.emb.h b/testdata/golden_cpp/int_sizes.emb.h index fe697e9..24bb197 100644 --- a/testdata/golden_cpp/int_sizes.emb.h +++ b/testdata/golden_cpp/int_sizes.emb.h @@ -1025,6 +1025,40 @@ MakeAlignedSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizesView( Container &&emboss_reserved_local_container) { + return GenericSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Sizes { } // namespace Sizes diff --git a/testdata/golden_cpp/large_array.emb.h b/testdata/golden_cpp/large_array.emb.h index 47b4511..3e18433 100644 --- a/testdata/golden_cpp/large_array.emb.h +++ b/testdata/golden_cpp/large_array.emb.h @@ -568,6 +568,40 @@ MakeAlignedUIntArrayView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericUIntArrayView< + /**/ ::emboss::support::IteratorStorage> +MakeUIntArrayView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericUIntArrayView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericUIntArrayView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeUIntArrayView( Container &&emboss_reserved_local_container) { + return GenericUIntArrayView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace UIntArray { } // namespace UIntArray diff --git a/testdata/golden_cpp/nested_structure.emb.h b/testdata/golden_cpp/nested_structure.emb.h index b953e31..f0bda9a 100644 --- a/testdata/golden_cpp/nested_structure.emb.h +++ b/testdata/golden_cpp/nested_structure.emb.h @@ -627,6 +627,40 @@ MakeAlignedContainerView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericContainerView< + /**/ ::emboss::support::IteratorStorage> +MakeContainerView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericContainerView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericContainerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeContainerView( Container &&emboss_reserved_local_container) { + return GenericContainerView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1127,6 +1161,40 @@ MakeAlignedBoxView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBoxView< + /**/ ::emboss::support::IteratorStorage> +MakeBoxView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBoxView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBoxView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBoxView( Container &&emboss_reserved_local_container) { + return GenericBoxView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1629,6 +1697,40 @@ MakeAlignedTruckView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericTruckView< + /**/ ::emboss::support::IteratorStorage> +MakeTruckView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericTruckView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericTruckView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeTruckView( Container &&emboss_reserved_local_container) { + return GenericTruckView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Container { } // namespace Container diff --git a/testdata/golden_cpp/next_keyword.emb.h b/testdata/golden_cpp/next_keyword.emb.h index 624c954..a82212e 100644 --- a/testdata/golden_cpp/next_keyword.emb.h +++ b/testdata/golden_cpp/next_keyword.emb.h @@ -697,6 +697,40 @@ MakeAlignedNextKeywordView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericNextKeywordView< + /**/ ::emboss::support::IteratorStorage> +MakeNextKeywordView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericNextKeywordView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericNextKeywordView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeNextKeywordView( Container &&emboss_reserved_local_container) { + return GenericNextKeywordView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace NextKeyword { } // namespace NextKeyword diff --git a/testdata/golden_cpp/no_enum_traits.emb.h b/testdata/golden_cpp/no_enum_traits.emb.h index 5f97e05..26ea1b1 100644 --- a/testdata/golden_cpp/no_enum_traits.emb.h +++ b/testdata/golden_cpp/no_enum_traits.emb.h @@ -531,6 +531,40 @@ MakeAlignedBarView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBarView< + /**/ ::emboss::support::IteratorStorage> +MakeBarView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBarView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBarView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBarView( Container &&emboss_reserved_local_container) { + return GenericBarView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Bar { } // namespace Bar diff --git a/testdata/golden_cpp/parameters.emb.h b/testdata/golden_cpp/parameters.emb.h index d60f164..7da5eea 100644 --- a/testdata/golden_cpp/parameters.emb.h +++ b/testdata/golden_cpp/parameters.emb.h @@ -1067,6 +1067,40 @@ MakeAlignedMultiVersionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericMultiVersionView< + /**/ ::emboss::support::IteratorStorage> +MakeMultiVersionView(::emboss::test::Product product, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericMultiVersionView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(product), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericMultiVersionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeMultiVersionView(::emboss::test::Product product, Container &&emboss_reserved_local_container) { + return GenericMultiVersionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(product), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1896,6 +1930,40 @@ MakeAlignedAxesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAxesView< + /**/ ::emboss::support::IteratorStorage> +MakeAxesView(::std::int32_t axes, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAxesView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(axes), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAxesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAxesView(::std::int32_t axes, Container &&emboss_reserved_local_container) { + return GenericAxesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(axes), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2658,6 +2726,40 @@ MakeAlignedAxisPairView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAxisPairView< + /**/ ::emboss::support::IteratorStorage> +MakeAxisPairView(::emboss::test::AxisType axis_type_a_parameter, ::emboss::test::AxisType axis_type_b_parameter, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAxisPairView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(axis_type_a_parameter),::std::forward(axis_type_b_parameter), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAxisPairView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAxisPairView(::emboss::test::AxisType axis_type_a_parameter, ::emboss::test::AxisType axis_type_b_parameter, Container &&emboss_reserved_local_container) { + return GenericAxisPairView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(axis_type_a_parameter),::std::forward(axis_type_b_parameter), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3186,6 +3288,40 @@ MakeAlignedAxesEnvelopeView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericAxesEnvelopeView< + /**/ ::emboss::support::IteratorStorage> +MakeAxesEnvelopeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAxesEnvelopeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAxesEnvelopeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAxesEnvelopeView( Container &&emboss_reserved_local_container) { + return GenericAxesEnvelopeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class AxisType : ::std::int64_t { GENERIC = static_cast(-1LL), X_AXIS = static_cast(1LL), @@ -4089,6 +4225,40 @@ MakeAlignedAxisView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAxisView< + /**/ ::emboss::support::IteratorStorage> +MakeAxisView(::emboss::test::AxisType axis_type_parameter, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAxisView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(axis_type_parameter), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAxisView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAxisView(::emboss::test::AxisType axis_type_parameter, Container &&emboss_reserved_local_container) { + return GenericAxisView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(axis_type_parameter), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Config { @@ -4507,6 +4677,40 @@ MakeAlignedConfigView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConfigView< + /**/ ::emboss::support::IteratorStorage> +MakeConfigView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConfigView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConfigView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConfigView( Container &&emboss_reserved_local_container) { + return GenericConfigView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4931,6 +5135,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ConfigVX @@ -5435,6 +5673,40 @@ MakeAlignedConfigVXView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConfigVXView< + /**/ ::emboss::support::IteratorStorage> +MakeConfigVXView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConfigVXView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConfigVXView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConfigVXView( Container &&emboss_reserved_local_container) { + return GenericConfigVXView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace StructWithUnusedParameter { @@ -5897,6 +6169,40 @@ MakeAlignedStructWithUnusedParameterView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage> +MakeStructWithUnusedParameterView(::std::int32_t x, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(x), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructWithUnusedParameterView(::std::int32_t x, Container &&emboss_reserved_local_container) { + return GenericStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(x), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6395,6 +6701,40 @@ MakeAlignedStructContainingStructWithUnusedParameterView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructContainingStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage> +MakeStructContainingStructWithUnusedParameterView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructContainingStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructContainingStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructContainingStructWithUnusedParameterView( Container &&emboss_reserved_local_container) { + return GenericStructContainingStructWithUnusedParameterView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6947,6 +7287,40 @@ MakeAlignedBiasedValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBiasedValueView< + /**/ ::emboss::support::IteratorStorage> +MakeBiasedValueView(::std::int32_t bias, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBiasedValueView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(bias), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBiasedValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBiasedValueView(::std::int32_t bias, Container &&emboss_reserved_local_container) { + return GenericBiasedValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(bias), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7459,6 +7833,40 @@ MakeAlignedVirtualFirstFieldWithParamView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage> +MakeVirtualFirstFieldWithParamView(::std::int32_t param, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(param), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeVirtualFirstFieldWithParamView(::std::int32_t param, Container &&emboss_reserved_local_container) { + return GenericVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(param), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7980,6 +8388,40 @@ MakeAlignedConstVirtualFirstFieldWithParamView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericConstVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage> +MakeConstVirtualFirstFieldWithParamView(::std::int32_t param, Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericConstVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage>( + ::std::forward(param), ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericConstVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeConstVirtualFirstFieldWithParamView(::std::int32_t param, Container &&emboss_reserved_local_container) { + return GenericConstVirtualFirstFieldWithParamView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::std::forward(param), ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -8594,6 +9036,40 @@ MakeAlignedSizedArrayOfBiasedValuesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizedArrayOfBiasedValuesView< + /**/ ::emboss::support::IteratorStorage> +MakeSizedArrayOfBiasedValuesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizedArrayOfBiasedValuesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizedArrayOfBiasedValuesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizedArrayOfBiasedValuesView( Container &&emboss_reserved_local_container) { + return GenericSizedArrayOfBiasedValuesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace MultiVersion { } // namespace MultiVersion diff --git a/testdata/golden_cpp/requires.emb.h b/testdata/golden_cpp/requires.emb.h index 500813b..e3cd9b7 100644 --- a/testdata/golden_cpp/requires.emb.h +++ b/testdata/golden_cpp/requires.emb.h @@ -1070,6 +1070,40 @@ MakeAlignedRequiresIntegersView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRequiresIntegersView< + /**/ ::emboss::support::IteratorStorage> +MakeRequiresIntegersView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRequiresIntegersView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRequiresIntegersView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRequiresIntegersView( Container &&emboss_reserved_local_container) { + return GenericRequiresIntegersView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1770,6 +1804,40 @@ MakeAlignedEmbossReservedAnonymousField2View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField2View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField2View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace RequiresBools @@ -2560,6 +2628,40 @@ MakeAlignedRequiresBoolsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRequiresBoolsView< + /**/ ::emboss::support::IteratorStorage> +MakeRequiresBoolsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRequiresBoolsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRequiresBoolsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRequiresBoolsView( Container &&emboss_reserved_local_container) { + return GenericRequiresBoolsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace RequiresEnums { struct EmbossReservedValidatorForC { @@ -3488,6 +3590,40 @@ MakeAlignedRequiresEnumsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRequiresEnumsView< + /**/ ::emboss::support::IteratorStorage> +MakeRequiresEnumsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRequiresEnumsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRequiresEnumsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRequiresEnumsView( Container &&emboss_reserved_local_container) { + return GenericRequiresEnumsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4202,6 +4338,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace RequiresWithOptionalFields @@ -4773,6 +4943,40 @@ MakeAlignedRequiresWithOptionalFieldsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRequiresWithOptionalFieldsView< + /**/ ::emboss::support::IteratorStorage> +MakeRequiresWithOptionalFieldsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRequiresWithOptionalFieldsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRequiresWithOptionalFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRequiresWithOptionalFieldsView( Container &&emboss_reserved_local_container) { + return GenericRequiresWithOptionalFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace RequiresInArrayElements { @@ -5208,6 +5412,40 @@ MakeAlignedElementView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericElementView< + /**/ ::emboss::support::IteratorStorage> +MakeElementView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericElementView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeElementView( Container &&emboss_reserved_local_container) { + return GenericElementView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace RequiresInArrayElements @@ -5624,6 +5862,40 @@ MakeAlignedRequiresInArrayElementsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRequiresInArrayElementsView< + /**/ ::emboss::support::IteratorStorage> +MakeRequiresInArrayElementsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRequiresInArrayElementsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRequiresInArrayElementsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRequiresInArrayElementsView( Container &&emboss_reserved_local_container) { + return GenericRequiresInArrayElementsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace RequiresIntegers { } // namespace RequiresIntegers diff --git a/testdata/golden_cpp/start_size_range.emb.h b/testdata/golden_cpp/start_size_range.emb.h index d9f0166..9b28021 100644 --- a/testdata/golden_cpp/start_size_range.emb.h +++ b/testdata/golden_cpp/start_size_range.emb.h @@ -733,6 +733,40 @@ MakeAlignedStartSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStartSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeStartSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStartSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStartSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStartSizeView( Container &&emboss_reserved_local_container) { + return GenericStartSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace StartSize { } // namespace StartSize diff --git a/testdata/golden_cpp/subtypes.emb.h b/testdata/golden_cpp/subtypes.emb.h index 860d554..d5c01e2 100644 --- a/testdata/golden_cpp/subtypes.emb.h +++ b/testdata/golden_cpp/subtypes.emb.h @@ -725,6 +725,40 @@ MakeAlignedInInView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericInInView< + /**/ ::emboss::support::IteratorStorage> +MakeInInView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericInInView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericInInView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeInInView( Container &&emboss_reserved_local_container) { + return GenericInInView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace In @@ -1569,6 +1603,40 @@ MakeAlignedInView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericInView< + /**/ ::emboss::support::IteratorStorage> +MakeInView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericInView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericInView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeInView( Container &&emboss_reserved_local_container) { + return GenericInView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1988,6 +2056,40 @@ MakeAlignedIn2View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericIn2View< + /**/ ::emboss::support::IteratorStorage> +MakeIn2View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericIn2View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericIn2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeIn2View( Container &&emboss_reserved_local_container) { + return GenericIn2View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace Out @@ -2963,6 +3065,40 @@ MakeAlignedOutView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericOutView< + /**/ ::emboss::support::IteratorStorage> +MakeOutView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericOutView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericOutView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeOutView( Container &&emboss_reserved_local_container) { + return GenericOutView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Out { namespace In { namespace InIn { diff --git a/testdata/golden_cpp/text_format.emb.h b/testdata/golden_cpp/text_format.emb.h index 46f257d..9d7e79b 100644 --- a/testdata/golden_cpp/text_format.emb.h +++ b/testdata/golden_cpp/text_format.emb.h @@ -549,6 +549,40 @@ MakeAlignedVanillaView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericVanillaView< + /**/ ::emboss::support::IteratorStorage> +MakeVanillaView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericVanillaView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericVanillaView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeVanillaView( Container &&emboss_reserved_local_container) { + return GenericVanillaView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1101,6 +1135,40 @@ MakeAlignedStructWithSkippedFieldsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructWithSkippedFieldsView< + /**/ ::emboss::support::IteratorStorage> +MakeStructWithSkippedFieldsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructWithSkippedFieldsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructWithSkippedFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructWithSkippedFieldsView( Container &&emboss_reserved_local_container) { + return GenericStructWithSkippedFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -1647,6 +1715,40 @@ MakeAlignedStructWithSkippedStructureFieldsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructWithSkippedStructureFieldsView< + /**/ ::emboss::support::IteratorStorage> +MakeStructWithSkippedStructureFieldsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructWithSkippedStructureFieldsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructWithSkippedStructureFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructWithSkippedStructureFieldsView( Container &&emboss_reserved_local_container) { + return GenericStructWithSkippedStructureFieldsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Vanilla { } // namespace Vanilla diff --git a/testdata/golden_cpp/uint_sizes.emb.h b/testdata/golden_cpp/uint_sizes.emb.h index df5eb3f..8c2b610 100644 --- a/testdata/golden_cpp/uint_sizes.emb.h +++ b/testdata/golden_cpp/uint_sizes.emb.h @@ -1077,6 +1077,40 @@ MakeAlignedSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSizesView( Container &&emboss_reserved_local_container) { + return GenericSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2069,6 +2103,40 @@ MakeAlignedBigEndianSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBigEndianSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeBigEndianSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBigEndianSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBigEndianSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBigEndianSizesView( Container &&emboss_reserved_local_container) { + return GenericBigEndianSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3061,6 +3129,40 @@ MakeAlignedAlternatingEndianSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericAlternatingEndianSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeAlternatingEndianSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericAlternatingEndianSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericAlternatingEndianSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeAlternatingEndianSizesView( Container &&emboss_reserved_local_container) { + return GenericAlternatingEndianSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4061,6 +4163,40 @@ MakeAlignedEnumSizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEnumSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeEnumSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEnumSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEnumSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEnumSizesView( Container &&emboss_reserved_local_container) { + return GenericEnumSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4488,6 +4624,40 @@ MakeAlignedEmbossReservedAnonymousField1View( emboss_reserved_local_size); } +template ::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage> +MakeEmbossReservedAnonymousField1View( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeEmbossReservedAnonymousField1View( Container &&emboss_reserved_local_container) { + return GenericEmbossReservedAnonymousField1View< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace ExplicitlySizedEnumSizes @@ -5156,6 +5326,40 @@ MakeAlignedExplicitlySizedEnumSizesView( emboss_reserved_local_data, emboss_reserved_local_size); } + +template ::value>::type> +inline GenericExplicitlySizedEnumSizesView< + /**/ ::emboss::support::IteratorStorage> +MakeExplicitlySizedEnumSizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericExplicitlySizedEnumSizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericExplicitlySizedEnumSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeExplicitlySizedEnumSizesView( Container &&emboss_reserved_local_container) { + return GenericExplicitlySizedEnumSizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} enum class Enum : ::std::uint64_t { VALUE1 = static_cast(1LL), VALUE10 = static_cast(10LL), @@ -6475,6 +6679,40 @@ MakeAlignedArraySizesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericArraySizesView< + /**/ ::emboss::support::IteratorStorage> +MakeArraySizesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericArraySizesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericArraySizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeArraySizesView( Container &&emboss_reserved_local_container) { + return GenericArraySizesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace Sizes { } // namespace Sizes diff --git a/testdata/golden_cpp/virtual_field.emb.h b/testdata/golden_cpp/virtual_field.emb.h index 140020a..8faef27 100644 --- a/testdata/golden_cpp/virtual_field.emb.h +++ b/testdata/golden_cpp/virtual_field.emb.h @@ -1118,6 +1118,40 @@ MakeAlignedStructureWithConstantsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithConstantsView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithConstantsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithConstantsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithConstantsView( Container &&emboss_reserved_local_container) { + return GenericStructureWithConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2152,6 +2186,40 @@ MakeAlignedStructureWithComputedValuesView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithComputedValuesView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithComputedValuesView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithComputedValuesView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithComputedValuesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithComputedValuesView( Container &&emboss_reserved_local_container) { + return GenericStructureWithComputedValuesView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -2792,6 +2860,40 @@ MakeAlignedStructureWithConditionalValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithConditionalValueView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithConditionalValueView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithConditionalValueView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithConditionalValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithConditionalValueView( Container &&emboss_reserved_local_container) { + return GenericStructureWithConditionalValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -3410,6 +3512,40 @@ MakeAlignedStructureWithValueInConditionView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithValueInConditionView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithValueInConditionView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithValueInConditionView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithValueInConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithValueInConditionView( Container &&emboss_reserved_local_container) { + return GenericStructureWithValueInConditionView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4112,6 +4248,40 @@ MakeAlignedStructureWithValuesInLocationView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithValuesInLocationView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithValuesInLocationView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithValuesInLocationView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithValuesInLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithValuesInLocationView( Container &&emboss_reserved_local_container) { + return GenericStructureWithValuesInLocationView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -4618,6 +4788,40 @@ MakeAlignedStructureWithBoolValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithBoolValueView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithBoolValueView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithBoolValueView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithBoolValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithBoolValueView( Container &&emboss_reserved_local_container) { + return GenericStructureWithBoolValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -5212,6 +5416,40 @@ MakeAlignedStructureWithEnumValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithEnumValueView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithEnumValueView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithEnumValueView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithEnumValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithEnumValueView( Container &&emboss_reserved_local_container) { + return GenericStructureWithEnumValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -5765,6 +6003,40 @@ MakeAlignedStructureWithBitsWithValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureWithBitsWithValueView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureWithBitsWithValueView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureWithBitsWithValueView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureWithBitsWithValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureWithBitsWithValueView( Container &&emboss_reserved_local_container) { + return GenericStructureWithBitsWithValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6355,6 +6627,40 @@ MakeAlignedBitsWithValueView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericBitsWithValueView< + /**/ ::emboss::support::IteratorStorage> +MakeBitsWithValueView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericBitsWithValueView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericBitsWithValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeBitsWithValueView( Container &&emboss_reserved_local_container) { + return GenericBitsWithValueView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -6832,6 +7138,40 @@ MakeAlignedStructureUsingForeignConstantsView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericStructureUsingForeignConstantsView< + /**/ ::emboss::support::IteratorStorage> +MakeStructureUsingForeignConstantsView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericStructureUsingForeignConstantsView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericStructureUsingForeignConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeStructureUsingForeignConstantsView( Container &&emboss_reserved_local_container) { + return GenericStructureUsingForeignConstantsView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -7338,6 +7678,40 @@ MakeAlignedHeaderView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericHeaderView< + /**/ ::emboss::support::IteratorStorage> +MakeHeaderView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericHeaderView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericHeaderView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeHeaderView( Container &&emboss_reserved_local_container) { + return GenericHeaderView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace SubfieldOfAlias @@ -7848,6 +8222,40 @@ MakeAlignedSubfieldOfAliasView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericSubfieldOfAliasView< + /**/ ::emboss::support::IteratorStorage> +MakeSubfieldOfAliasView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericSubfieldOfAliasView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericSubfieldOfAliasView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeSubfieldOfAliasView( Container &&emboss_reserved_local_container) { + return GenericSubfieldOfAliasView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -8396,6 +8804,40 @@ MakeAlignedRestrictedAliasView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRestrictedAliasView< + /**/ ::emboss::support::IteratorStorage> +MakeRestrictedAliasView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRestrictedAliasView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRestrictedAliasView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRestrictedAliasView( Container &&emboss_reserved_local_container) { + return GenericRestrictedAliasView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -8933,6 +9375,40 @@ MakeAlignedXView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericXView< + /**/ ::emboss::support::IteratorStorage> +MakeXView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericXView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericXView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeXView( Container &&emboss_reserved_local_container) { + return GenericXView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace HasField @@ -9590,6 +10066,40 @@ MakeAlignedHasFieldView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericHasFieldView< + /**/ ::emboss::support::IteratorStorage> +MakeHasFieldView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericHasFieldView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericHasFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeHasFieldView( Container &&emboss_reserved_local_container) { + return GenericHasFieldView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -10212,6 +10722,40 @@ MakeAlignedVirtualUnconditionallyUsesConditionalView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericVirtualUnconditionallyUsesConditionalView< + /**/ ::emboss::support::IteratorStorage> +MakeVirtualUnconditionallyUsesConditionalView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericVirtualUnconditionallyUsesConditionalView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericVirtualUnconditionallyUsesConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeVirtualUnconditionallyUsesConditionalView( Container &&emboss_reserved_local_container) { + return GenericVirtualUnconditionallyUsesConditionalView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -10723,6 +11267,40 @@ MakeAlignedRView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericRView< + /**/ ::emboss::support::IteratorStorage> +MakeRView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericRView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericRView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeRView( Container &&emboss_reserved_local_container) { + return GenericRView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + } // namespace UsesSize @@ -11222,6 +11800,40 @@ MakeAlignedUsesSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericUsesSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeUsesSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericUsesSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericUsesSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeUsesSizeView( Container &&emboss_reserved_local_container) { + return GenericUsesSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -11718,6 +12330,40 @@ MakeAlignedUsesExternalSizeView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericUsesExternalSizeView< + /**/ ::emboss::support::IteratorStorage> +MakeUsesExternalSizeView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericUsesExternalSizeView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericUsesExternalSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeUsesExternalSizeView( Container &&emboss_reserved_local_container) { + return GenericUsesExternalSizeView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + @@ -12807,6 +13453,40 @@ MakeAlignedImplicitWriteBackView( emboss_reserved_local_size); } +template ::value>::type> +inline GenericImplicitWriteBackView< + /**/ ::emboss::support::IteratorStorage> +MakeImplicitWriteBackView( Iterator emboss_reserved_local_begin, + Iterator emboss_reserved_local_end) { + return GenericImplicitWriteBackView< + /**/ ::emboss::support::IteratorStorage>( + ::emboss::support::IteratorStorage( + ::std::move(emboss_reserved_local_begin), + ::std::move(emboss_reserved_local_end))); +} + +template ::type>::type>::value && + !::std::is_pointer::type>::value>::type> +inline GenericImplicitWriteBackView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>> +MakeImplicitWriteBackView( Container &&emboss_reserved_local_container) { + return GenericImplicitWriteBackView< + /**/ ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>>( + ::emboss::support::IteratorStorage< + decltype(::std::begin(::std::declval()))>( + ::std::begin(emboss_reserved_local_container), + ::std::end(emboss_reserved_local_container))); +} + namespace StructureWithConstants { } // namespace StructureWithConstants