static void mergeItemImpl()

in src/main/java/org/apache/datasketches/kll/KllItemsHelper.java [127:243]
75 lines of code
13 McCabe index (conditional complexity)

  static <T> void mergeItemImpl(final KllItemsSketch<T> mySketch,
      final KllItemsSketch<T> otherItmSk, final Comparator<? super T> comp) {
    if (otherItmSk.isEmpty()) { return; }

    //capture my key mutable fields before doing any merging
    final boolean myEmpty = mySketch.isEmpty();
    final Object myMin = myEmpty ? null : mySketch.getMinItem();
    final Object myMax = myEmpty ? null : mySketch.getMaxItem();
    final int myMinK = mySketch.getMinK();
    final long finalN = Math.addExact(mySketch.getN(), otherItmSk.getN());

    //buffers that are referenced multiple times
    final int otherNumLevels = otherItmSk.getNumLevels();
    final int[] otherLevelsArr = otherItmSk.levelsArr;
    final Object[] otherItemsArr;

    //MERGE: update this sketch with level0 items from the other sketch
    if (otherItmSk.isCompactSingleItem()) {
      updateItem(mySketch, otherItmSk.getSingleItem());
      otherItemsArr = new Object[0];
    } else {
      otherItemsArr = otherItmSk.getTotalItemsArray();
      for (int i = otherLevelsArr[0]; i < otherLevelsArr[1]; i++) {
       updateItem(mySketch, otherItemsArr[i]);
      }
    }

    //After the level 0 update, we capture the intermediate state of levels and items arrays...
    final int myCurNumLevels = mySketch.getNumLevels();
    final int[] myCurLevelsArr = mySketch.levelsArr;
    final Object[] myCurItemsArr = mySketch.getTotalItemsArray();

    // then rename them and initialize in case there are no higher levels
    int myNewNumLevels = myCurNumLevels;
    int[] myNewLevelsArr = myCurLevelsArr;
    Object[] myNewItemsArr = myCurItemsArr;

    //merge higher levels if they exist
    if (otherNumLevels > 1  && !otherItmSk.isCompactSingleItem()) {
      final int tmpSpaceNeeded = mySketch.getNumRetained()
          + KllHelper.getNumRetainedAboveLevelZero(otherNumLevels, otherLevelsArr);
      final Object[] workbuf = new Object[tmpSpaceNeeded];

      final int provisionalNumLevels = max(myCurNumLevels, otherNumLevels);

      final int ub = max(KllHelper.ubOnNumLevels(finalN), provisionalNumLevels);
      final int[] worklevels = new int[ub + 2]; // ub+1 does not work
      final int[] outlevels  = new int[ub + 2];

      populateItemWorkArrays(workbuf, worklevels, provisionalNumLevels,
          myCurNumLevels, myCurLevelsArr, myCurItemsArr,
          otherNumLevels, otherLevelsArr, otherItemsArr, comp);

      // notice that workbuf is being used as both the input and output
      final int[] result = generalItemsCompress(mySketch.getK(), mySketch.getM(), provisionalNumLevels,
          workbuf, worklevels, workbuf, outlevels, mySketch.isLevelZeroSorted(), KllSketch.random, comp);
      final int targetItemCount = result[1]; //was finalCapacity. Max size given k, m, numLevels
      final int curItemCount = result[2]; //was finalPop

      // now we need to finalize the results for mySketch

      //THE NEW NUM LEVELS
      myNewNumLevels = result[0];
      assert myNewNumLevels <= ub; // ub may be much bigger

      // THE NEW ITEMS ARRAY
      myNewItemsArr = (targetItemCount == myCurItemsArr.length)
          ? myCurItemsArr
          : new Object[targetItemCount];
      final int freeSpaceAtBottom = targetItemCount - curItemCount;

      //shift the new items array create space at bottom
      System.arraycopy(workbuf, outlevels[0], myNewItemsArr, freeSpaceAtBottom, curItemCount);
      final int theShift = freeSpaceAtBottom - outlevels[0];

      //calculate the new levels array length
      final int finalLevelsArrLen;
      if (myCurLevelsArr.length < myNewNumLevels + 1) { finalLevelsArrLen = myNewNumLevels + 1; }
      else { finalLevelsArrLen = myCurLevelsArr.length; }

      //THE NEW LEVELS ARRAY
      myNewLevelsArr = new int[finalLevelsArrLen];
      for (int lvl = 0; lvl < myNewNumLevels + 1; lvl++) { // includes the "extra" index
        myNewLevelsArr[lvl] = outlevels[lvl] + theShift;
      }

      //MEMORY SPACE MANAGEMENT
      //not used
      //extra spaces to make comparison with other helpers easier
      //
      //
      //
    } //end of updating levels above level 0

    //Update Preamble:
    mySketch.setN(finalN);
    if (otherItmSk.isEstimationMode()) { //otherwise the merge brings over exact items.
      mySketch.setMinK(min(myMinK, otherItmSk.getMinK()));
    }

    //Update numLevels, levelsArray, items
    mySketch.setNumLevels(myNewNumLevels);
    mySketch.setLevelsArray(myNewLevelsArr);
    mySketch.setItemsArray(myNewItemsArr);

    //Update min, max items
    final Object otherMin = otherItmSk.getMinItem();
    final Object otherMax = otherItmSk.getMaxItem();
    if (myEmpty) {
      mySketch.setMinItem(otherMin);
      mySketch.setMaxItem(otherMax);
    } else {
      mySketch.setMinItem(Util.minT(myMin, otherMin, comp));
      mySketch.setMaxItem(Util.maxT(myMax, otherMax, comp));
    }
    assert KllHelper.sumTheSampleWeights(mySketch.getNumLevels(), mySketch.levelsArr) == mySketch.getN();
  }