@tobiasdiez If that really matters, we could invokeAll and assign priorities to the fetchers or something like that. I'm not sure if the preprint (in reality) really differs (or how often) from the published paper.
Would still give us the parallelism.
And the more fetcher we have we can still keep the time complexity ~ N and not N*NumFetcher.

Priorities or clustering in Authority, Journals and preprints would be a good solution in my opinion.

I know a few instances where authors didn't update their arxiv preprint with the revised and published version. Since even the slightest changes could shift the equation or theorem numbering, having the published PDF is in general desirable.

I thought about this for a moment.
The problem that still persists is that we

• have a time complexity of max(v_1,..., v_n) then instead of min(v_1,..., v_n)
• decision complexity goes up (clustering, invokingall, checking which highest rated authority has a url, downloading this URL (hopefully it succeeds then if not probably the download is broken all the time as it will always be the highest priority....)

What really annoys me is that the download takes so much time now.
Your priority might be to get the right document.

Note sure which way to go here.

At the moment we try the original publisher for 10 seconds via the DOIResolution.
Afterwards there might be better alternatives like IEEE than GoogleScholar, but it will not be the original publisher site then anyhow!
Maybe we can risk it 😄

Maybe we can offer a switch? E.g. Prefer Official papers over Preprints?
Google Scholar has maybe PDF but the bibtex data of it are worse than every other page
We maybe could also give semanticscholar a try: https://www.semanticscholar.org/
They link to the orgiinal paper

I implemented a possible solution in #3882
Not 100% sure if it is correct but it could be a step into the right direction.
Fetching should be a little faster now as all fetchers are queried in parallel.
I'm still not sure if I like it that way.

Ok, these are good points. What do think about combining both approaches: we cluster the fetcher by trust level and run all fetchers in a cluster in parallel. Thus the performance is still min in each cluster.

Something like:

for (TrustLevel trustLevel : TrustLevel.values()) {
    var tasks = fetchers.stream()
            .filter(fetcher::getTrustLevel == trustLevel)
            .map(fetcher -> () -> fetcher.fetch(entry))
            .collect(list());

     try {
         return executer.invokeAny(tasks);
     } catch( ExecutionException) {
          // No fetcher successful, continue in next trust level bracket
     } 
}

(Fetcher.fetch should throw an exception if no url could be found, otherwise the above code does not work).

It's probably easier an more clear to just run all fetchers as it is now and then select the best authority. Don't see too much benefits running them after another except for multiple code loops then.
Not sure but most of the times we will get the PDF from the lowest authority which means we need to traverse the loop multiple times. I gues the average performance will be better when we run all of them in parallel then.

Closed in favor of #3882