Hi Alan,
On 25/08/2022 06:36, Alan Ruttenberg wrote:
So in order to implement this I need to know the interface to use for the lambda? Presumably I can determine this with reflection.
You learn this not by reflection but by reading the library's source code, which you've done below to determine that the interface is Consumer not Function.
An example of one of the functions that takes the lambda is defined:
public final NitfSegmentsFlow forEachImageSegment(final Consumer<ImageSegment> consumer)
But consumer has two methods: accept and andThen
As Alessio said andThen() has a default implementation in Consumer (just as it did in Function).
Eventually it looks like accept is called on the consumer.
That sounds right.
So in this case it looks like I need to use jinterface-implementation and define the accept method, no lambda necessary?
You need to implement an accept() method somehow. One way is similar to how I'd shown an implementation of java.util.function.Function.apply(). (At the time I didn't know what type of object your library wanted so I assumed for concreteness that it was Function. Now we know it's Consumer. The principle of the technique I showed still applies.)
I showed how to implement an adaptor class in Java. I noted that you could probably do the equivalent from ABCL. Alessio pointed out that that way was to use jinterface-implementation. So you don't _need_ to use a jinterface-implementation approach, but you can.
You're right, it doesn't seem like you need to think about Java lambdas, just a Java interface (Consumer) and getting a new class that implements that interface and instantiating it to get an object. Whether you write that class in Java or by using jinterface-implementation in ABCL is a different matter.
What confuses me now is if a lambda is passed as the test code I'm reading does:
forEachImageSegment(imageSegment -> {do something})
How does java know that the lambda is the implementation of accept rather than andThen.
As Alessio described, Java can only know this if an interface has a single (abstract) method in it. It then assumes that the lambda represents an implementation of that single method. You can see from the javadoc for Consumer that though it has more than one method, all but accept() have a "default" next to them, which means that the Consumer interface already provides a concrete implementation of them. That is, they aren't abstract. accept() doesn't have a "default" next to it, so it's abstract, meaning all concrete classes that claim to implement the interface must provide a concrete implementation of (at least) accept().
Or more practically, how do I figure out which method to implement without reading the source code?
1. By reading the javadoc for Consumer. I showed you an example for Function, which specifies a number of methods but only one (apply()) was abstract. https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html
2. By asking on this list apparently :-) The answer is accept().
---- If you want to take a small step first, modify what I sent you earlier to work with Consumer instead of Function. The modification should be trivial. Once you've got that working, and if you don't like that the adaptor is written in Java or like experimenting, then explore the jinterface-implementation approach to do everything directly from ABCL.