Java Optionals in layered entities

[hrstoyanov]

Hello, I created this test layered entity interface:

public interface SomeTestEntity extends Entity {
    Optional<String> phone();
    Optional<String> email();
    default String pleaseDoNotGenerateAnyCode(){
        return phone().orElse(email().orElse("nothing"));
    }
}

The generated code is:

public class SomeTestEntityEntity extends EntityLayerIdentity implements SomeTestEntity
{
	protected SomeTestEntityEntity()
	{
		super();
	}

	@Override
	protected SomeTestEntity entityData()
	{
		return (SomeTestEntity)super.entityData();
	}

	@Override
	public final Optional<String> phone()
	{
		return this.entityData().phone();
	}

	@Override
	public final Optional<String> email()
	{
		return this.entityData().email();
	}

	@Override
	public String toString()
	{
		return SomeTestEntityAppendable.toString(this);
	}
}
...
public class SomeTestEntityData extends EntityData implements SomeTestEntity
{
	private final Optional<String> phone;
	private final Optional<String> email;

	protected SomeTestEntityData(final SomeTestEntity entity,
		final Optional<String> phone,
		final Optional<String> email)
	{
		super(entity);

		this.phone = phone;
		this.email = email;
	}

	@Override
	public Optional<String> phone()
	{
		return this.phone;
	}

	@Override
	public Optional<String> email()
	{
		return this.email;
	}

	@Override
	public String toString()
	{
		return SomeTestEntityAppendable.toString(this);
	}
}

The code is mostly OK (and it did not generate code for the default method, good!) but it would be nice to have the option to treat java Optional<>'s specially - basically take the raw objects as inputs, not their Optional wrappers. here is an example of generated code (data):

public class SomeTestEntityData extends EntityData implements SomeTestEntity
{
	private final String phone;
	private final String email;

	protected SomeTestEntityData(final SomeTestEntity entity,
		final String phone,
		final String email)
	{
		super(entity);

		this.phone = phone;
		this.email = email;
	}

	@Override
	public Optional<String> phone()
	{
		return Optional.ofNullable(this.phone);
	}

	@Override
	public Optional<String> email()
	{
		return Optional.ofNullable(this.email);
	}

	@Override
	public String toString()
	{
		return SomeTestEntityAppendable.toString(this);
	}
}

I think this can be achieved by some adding an annotation like @OptionalGeneration(OnReturnsOnly=true) (or something similar):

@OptionalGeneration(OnReturnsOnly=true)
public interface SomeTestEntity extends Entity {
    Optional<String> phone();
    Optional<String> email();
    default String pleaseDoNotGenerateAnyCode(){
        return phone().orElse(email().orElse("nothing"));
    }
}

Such generated data objects would take less RAM (I think) and are more conformant with the recommended use of Optional<>'s, ... also, would that help with optimizing the serialization - how are optionals processed?

See :
https://medium.com/@muhammad.ahsan/java-optional-gist-of-tech-talk-by-stuart-marks-at-devoxx-790ae4565bde
https://nipafx.dev/java-optional-opinions/
https://nipafx.dev/intention-revealing-code-java-8-optional