protected DiffEqualOrdinalMap mapMatchingFromOrdinals()

in hollow/src/main/java/com/netflix/hollow/tools/diff/exact/mapper/DiffEqualityTypeMapper.java [95:162]
59 lines of code
14 McCabe index (conditional complexity)

    protected DiffEqualOrdinalMap mapMatchingFromOrdinals(final int[] hashedToOrdinals) {
        PopulatedOrdinalListener listener = fromState.getListener(PopulatedOrdinalListener.class);
        final BitSet fromPopulatedOrdinals = listener.getPopulatedOrdinals();
        final int ordinalSpaceLength = fromPopulatedOrdinals.length();

        SimultaneousExecutor executor = new SimultaneousExecutor(1.5d, getClass(), "map-matching-from-ordinals");
        final int numThreads = executor.getCorePoolSize();
        final LongList[] matchPairResults = new LongList[numThreads];

        for(int i=0;i<numThreads;i++) {
            final int threadNumber = i;
            matchPairResults[threadNumber] = new LongList();
            executor.execute(() -> {
                EqualityDeterminer equalityDeterminer = getEqualityDeterminer();

                for(int t=threadNumber;t <ordinalSpaceLength;t+=numThreads) {
                    if(fromPopulatedOrdinals.get(t)) {
                        int hashCode = fromRecordHashCode(t);
                        if(hashCode != -1) {
                            int bucket = hashCode & (hashedToOrdinals.length - 1);
                            while(hashedToOrdinals[bucket] != -1) {
                                if(equalityDeterminer.recordsAreEqual(t, hashedToOrdinals[bucket])) {
                                    matchPairResults[threadNumber].add(((long) t << 32) | hashedToOrdinals[bucket]);
                                }
                                bucket = (bucket + 1) & (hashedToOrdinals.length - 1);
                            }
                        }
                    }
                }
            });
        }

        try {
            executor.awaitSuccessfulCompletion();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }

        int numMatches = 0;
        for(int i=0;i<matchPairResults.length;i++) {
            numMatches += matchPairResults[i].size();
        }

        CombinedMatchPairResultsIterator resultsIterator = new CombinedMatchPairResultsIterator(matchPairResults);

        DiffEqualOrdinalMap ordinalMap = new DiffEqualOrdinalMap(numMatches);

        if(oneToOne) {
            BitSet alreadyMappedToOrdinals = new BitSet(toState.maxOrdinal() + 1);
            while(resultsIterator.next()) {
                int fromOrdinal = resultsIterator.fromOrdinal();
                IntList toOrdinals = resultsIterator.toOrdinals();
                for(int i=0;i<toOrdinals.size();i++) {
                    if(!alreadyMappedToOrdinals.get(toOrdinals.get(i))) {
                        alreadyMappedToOrdinals.set(toOrdinals.get(i));
                        ordinalMap.putEqualOrdinal(fromOrdinal, toOrdinals.get(i));
                        break;
                    }
                }
            }
        } else {
            while(resultsIterator.next()) {
                ordinalMap.putEqualOrdinals(resultsIterator.fromOrdinal(), resultsIterator.toOrdinals());
            }
        }

        return ordinalMap;
    }