default Optional getTypeReferenceForProperty()

in code-generation/types-base/src/main/java/org/apache/plc4x/plugins/codegenerator/types/definitions/ComplexTypeDefinition.java [400:451]
45 lines of code
7 McCabe index (conditional complexity)

    default Optional<TypeReference> getTypeReferenceForProperty(String propertyName) {
        Objects.requireNonNull(propertyName);
        // If this is a built-in type, use that.
        if (BuiltIns.builtInFields.containsKey(propertyName)) {
            return Optional.of(BuiltIns.builtInFields.get(propertyName));
        }
        // Check if the expression root is referencing a field
        final Optional<PropertyField> propertyFieldOptional = getPropertyFields().stream()
                .filter(propertyField -> propertyField.getName().equals(propertyName))
                .findFirst();
        if (propertyFieldOptional.isPresent()) {
            return propertyFieldOptional.map(PropertyField::getType);
        }
        // Check if the expression is a ImplicitField
        final Optional<ImplicitField> implicitFieldOptional = getFields().stream()
                .filter(ImplicitField.class::isInstance)
                .map(ImplicitField.class::cast)
                .filter(implicitField -> implicitField.getName().equals(propertyName))
                .findFirst();
        if (implicitFieldOptional.isPresent()) {
            return implicitFieldOptional.map(ImplicitField::getType);
        }
        // Check if the expression is a VirtualField
        final Optional<VirtualField> virtualFieldOptional = getFields().stream()
                .filter(VirtualField.class::isInstance)
                .map(VirtualField.class::cast)
                .filter(virtualField -> virtualField.getName().equals(propertyName))
                .findFirst();
        if (virtualFieldOptional.isPresent()) {
            return virtualFieldOptional.map(VirtualField::getType);
        }
        // Check if the expression root is referencing an argument
        final Optional<Argument> argumentOptional = getAllParserArguments()
                .orElse(Collections.emptyList())
                .stream()
                .filter(argument -> argument.getName().equals(propertyName))
                .findFirst();
        if (argumentOptional.isPresent()) {
            return argumentOptional.map(Argument::getType);
        }
        // Check if the expression is a DiscriminatorField
        // This is a more theoretical case where the expression is referencing a discriminator value of the current type
        final Optional<DiscriminatorField> discriminatorFieldOptional = getFields().stream()
                .filter(DiscriminatorField.class::isInstance)
                .map(DiscriminatorField.class::cast)
                .filter(discriminatorField -> discriminatorField.getName().equals(propertyName))
                .findFirst();
        if (discriminatorFieldOptional.isPresent()) {
            return discriminatorFieldOptional.map(DiscriminatorField::getType);
        }
        return Optional.empty();
    }