private void logMapLocations(final ReferenceDataResult result) {
        // We need to compute these values now rather than in the lamba, else
        // they will change when the ReferenceDataResult is changed during recursion.
        // May want to consider storing the chain of results so we can get at any of the
        // result levels.
        final String mapName = result.getRefDataValueProxy()
                .map(RefDataValueProxy::getMapName)
                .orElse(null);
        final List<RefStreamDefinition> qualifyingStreams = new ArrayList<>(result.getQualifyingStreams());
        final int effectiveStreamCount = result.getEffectiveStreams().size();

        result.logLazyTemplate(Severity.INFO,
                "Map '{}' found in {} out of {} effective streams: [{}]",
                () -> {
                    final String streamsStr = qualifyingStreams
                            .stream()
                            .map(RefStreamDefinition::getStreamId)
                            .map(String::valueOf)
                            .collect(Collectors.joining(", "));
                    return Arrays.asList(
                            mapName,
                            qualifyingStreams.size(),
                            effectiveStreamCount,
                            streamsStr);
                });
    }
<p>
Given a {@link LookupIdentifier} and a list of ref data pipelines, ensure that
the data required to perform the lookup is in the ref store. This method will not
perform the lookup, instead it will populate the {@link ReferenceDataResult} with
a proxy object that can later be used to do the lookup.
</p>

@param pipelineReferences The references to look for reference data in.
@param lookupIdentifier   The identifier to lookup in the reference data
@param result             The reference result object containing the proxy object for performing the lookup
@return The passed result object
stroom-pipeline/src/main/java/stroom/pipeline/refdata/ReferenceData.java