This IDL struct definition:

```c++
    simple_array_fields:
        description: UnitTest for arrays of simple types
        fields:
            field1:
                type: array<string>
            field2:
                type: array<int>
            field3:
                type: array<double>
            field4:
                type: array<bindata_generic>
            field5:
                type: array<bindata_uuid>
```

Produces this highly redundant 200 line `parseProtected` function, with the
trie search and structure inlined into the overall parse function logic.

```c++

void Simple_array_fields::parseProtected(const IDLParserContext& ctxt, const BSONObj& bsonObject) {
    const size_t kField1Bit = 0;
    const size_t kField2Bit = 1;
    const size_t kField3Bit = 2;
    const size_t kField4Bit = 3;
    const size_t kField5Bit = 4;
    std::bitset<5> usedFields;
    setSerializationContext(_isCommandReply ? SerializationContext::stateCommandReply() : ctxt.getSerializationContext());

    for (const auto& element :bsonObject) {
        const auto fieldName = element.fieldNameStringData();

        if (fieldName.size() >= 5 && std::char_traits<char>::compare(fieldName.rawData() + 0, "field", 5) == 0) {
            if (fieldName.size() >= 6) {
                if (fieldName[5] == '5') {
                    if (fieldName.size() == 6) {
                        if (MONGO_likely(ctxt.checkAndAssertType(element, Array))) {
                            if (MONGO_unlikely(usedFields[kField5Bit])) {
                                ctxt.throwDuplicateField(element);
                            }

                            usedFields.set(kField5Bit);

                            _hasMembers.markPresent(static_cast<size_t>(RequiredFields::field5));
                            DecimalCounter<std::uint32_t> expectedFieldNumber{0};
                            const IDLParserContext arrayCtxt(kField5FieldName, &ctxt, ctxt.getTenantId(), getSerializationContext());
                            std::vector<std::array<std::uint8_t, 16>> values;

                            const BSONObj arrayObject = element.Obj();
                            for (const auto& arrayElement : arrayObject) {
                                const auto arrayFieldName = arrayElement.fieldNameStringData();
                                if (MONGO_likely(arrayFieldName == expectedFieldNumber)) {
                                    if (MONGO_likely(arrayCtxt.checkAndAssertBinDataType(arrayElement, newUUID))) {
                                        values.emplace_back(arrayElement.uuid());
                                    }
                                }
                                else {
                                    arrayCtxt.throwBadArrayFieldNumberSequence(arrayFieldName, expectedFieldNumber);
                                }
                                ++expectedFieldNumber;
                            }
                            _field5 = std::move(values);
                        }
                        continue;
                    }
                }
                else if (fieldName[5] == '2') {
                    if (fieldName.size() == 6) {
                        if (MONGO_likely(ctxt.checkAndAssertType(element, Array))) {
                            if (MONGO_unlikely(usedFields[kField2Bit])) {
                                ctxt.throwDuplicateField(element);
                            }

                            usedFields.set(kField2Bit);

                            _hasMembers.markPresent(static_cast<size_t>(RequiredFields::field2));
                            DecimalCounter<std::uint32_t> expectedFieldNumber{0};
                            const IDLParserContext arrayCtxt(kField2FieldName, &ctxt, ctxt.getTenantId(), getSerializationContext());
                            std::vector<std::int32_t> values;

                            const BSONObj arrayObject = element.Obj();
                            for (const auto& arrayElement : arrayObject) {
                                const auto arrayFieldName = arrayElement.fieldNameStringData();
                                if (MONGO_likely(arrayFieldName == expectedFieldNumber)) {
                                    if (MONGO_likely(arrayCtxt.checkAndAssertType(arrayElement, NumberInt))) {
                                        values.emplace_back(arrayElement._numberInt());
                                    }
                                }
                                else {
                                    arrayCtxt.throwBadArrayFieldNumberSequence(arrayFieldName, expectedFieldNumber);
                                }
                                ++expectedFieldNumber;
                            }
                            _field2 = std::move(values);
                        }
                        continue;
                    }
                }
                else if (fieldName[5] == '4') {
                    if (fieldName.size() == 6) {
                        if (MONGO_likely(ctxt.checkAndAssertType(element, Array))) {
                            if (MONGO_unlikely(usedFields[kField4Bit])) {
                                ctxt.throwDuplicateField(element);
                            }

                            usedFields.set(kField4Bit);

                            _hasMembers.markPresent(static_cast<size_t>(RequiredFields::field4));
                            DecimalCounter<std::uint32_t> expectedFieldNumber{0};
                            const IDLParserContext arrayCtxt(kField4FieldName, &ctxt, ctxt.getTenantId(), getSerializationContext());
                            std::vector<std::vector<std::uint8_t>> values;

                            const BSONObj arrayObject = element.Obj();
                            for (const auto& arrayElement : arrayObject) {
                                const auto arrayFieldName = arrayElement.fieldNameStringData();
                                if (MONGO_likely(arrayFieldName == expectedFieldNumber)) {
                                    if (MONGO_likely(arrayCtxt.checkAndAssertBinDataType(arrayElement, BinDataGeneral))) {
                                        values.emplace_back(arrayElement._binDataVector());
                                    }
                                }
                                else {
                                    arrayCtxt.throwBadArrayFieldNumberSequence(arrayFieldName, expectedFieldNumber);
                                }
                                ++expectedFieldNumber;
                            }
                            _field4 = std::move(values);
                        }
                        continue;
                    }
                }
                else if (fieldName[5] == '1') {
                    if (fieldName.size() == 6) {
                        if (MONGO_likely(ctxt.checkAndAssertType(element, Array))) {
                            if (MONGO_unlikely(usedFields[kField1Bit])) {
                                ctxt.throwDuplicateField(element);
                            }

                            usedFields.set(kField1Bit);

                            _hasMembers.markPresent(static_cast<size_t>(RequiredFields::field1));
                            DecimalCounter<std::uint32_t> expectedFieldNumber{0};
                            const IDLParserContext arrayCtxt(kField1FieldName, &ctxt, ctxt.getTenantId(), getSerializationContext());
                            std::vector<std::string> values;

                            const BSONObj arrayObject = element.Obj();
                            for (const auto& arrayElement : arrayObject) {
                                const auto arrayFieldName = arrayElement.fieldNameStringData();
                                if (MONGO_likely(arrayFieldName == expectedFieldNumber)) {
                                    if (MONGO_likely(arrayCtxt.checkAndAssertType(arrayElement, String))) {
                                        values.emplace_back(arrayElement.str());
                                    }
                                }
                                else {
                                    arrayCtxt.throwBadArrayFieldNumberSequence(arrayFieldName, expectedFieldNumber);
                                }
                                ++expectedFieldNumber;
                            }
                            _field1 = std::move(values);
                        }
                        continue;
                    }
                }
                else if (fieldName[5] == '3') {
                    if (fieldName.size() == 6) {
                        if (MONGO_likely(ctxt.checkAndAssertType(element, Array))) {
                            if (MONGO_unlikely(usedFields[kField3Bit])) {
                                ctxt.throwDuplicateField(element);
                            }

                            usedFields.set(kField3Bit);

                            _hasMembers.markPresent(static_cast<size_t>(RequiredFields::field3));
                            DecimalCounter<std::uint32_t> expectedFieldNumber{0};
                            const IDLParserContext arrayCtxt(kField3FieldName, &ctxt, ctxt.getTenantId(), getSerializationContext());
                            std::vector<double> values;

                            const BSONObj arrayObject = element.Obj();
                            for (const auto& arrayElement : arrayObject) {
                                const auto arrayFieldName = arrayElement.fieldNameStringData();
                                if (MONGO_likely(arrayFieldName == expectedFieldNumber)) {
                                    if (MONGO_likely(arrayCtxt.checkAndAssertType(arrayElement, NumberDouble))) {
                                        values.emplace_back(arrayElement._numberDouble());
                                    }
                                }
                                else {
                                    arrayCtxt.throwBadArrayFieldNumberSequence(arrayFieldName, expectedFieldNumber);
                                }
                                ++expectedFieldNumber;
                            }
                            _field3 = std::move(values);
                        }
                        continue;
                    }
                }
            }
        }
        ctxt.throwUnknownField(fieldName);
    }

    constexpr std::uint64_t requiredFieldBitMask = (1ULL << kField1Bit) | (1ULL << kField2Bit) | (1ULL << kField3Bit) | (1ULL << kField4Bit) | (1ULL << kField5Bit);
    std::bitset<5> requiredFields(requiredFieldBitMask);
    bool hasMissingRequiredFields = (requiredFields & usedFields) != requiredFields;
    if (hasMissingRequiredFields) {
        if (!usedFields[kField1Bit]) {
            ctxt.throwMissingField(kField1FieldName);
        }
        if (!usedFields[kField2Bit]) {
            ctxt.throwMissingField(kField2FieldName);
        }
        if (!usedFields[kField3Bit]) {
            ctxt.throwMissingField(kField3FieldName);
        }
        if (!usedFields[kField4Bit]) {
            ctxt.throwMissingField(kField4FieldName);
        }
        if (!usedFields[kField5Bit]) {
            ctxt.throwMissingField(kField5FieldName);
        }
    }

}
```