private String extractGroupId(PlexusConfiguration c) {
        return c.getChild("groupId").getValue();
    }

    private String extractArtifactId(PlexusConfiguration c) {
        return c.getChild("artifactId").getValue();
    }

    private String extractVersion(PlexusConfiguration c) {
        return c.getChild("version").getValue();
    }

    private String extractGoalPrefix(PlexusConfiguration c) {

                try {
                    list.add(new LabelTypePattern(labelType.getValue(), includedPaths, excludedPaths));
                } catch (final Exception e) {
                    logger.warn("Failed to create a matching pattern of a label: {}, includedPaths:{}, excludedPaths:{}",
                            labelType.getValue(), includedPaths, excludedPaths, e);
                }
            }
        }

      int columnIndex = requireNonNull(columnKeyToIndex.get(columnKey));
      V existingValue = values[rowIndex][columnIndex];
      checkNoDuplicate(rowKey, columnKey, existingValue, cell.getValue());
      values[rowIndex][columnIndex] = cell.getValue();
      rowCounts[rowIndex]++;
      columnCounts[columnIndex]++;
      cellRowIndices[i] = rowIndex;
      cellColumnIndices[i] = columnIndex;
    }

        assertSame(entry.getValue(), cache.asMap().putIfAbsent(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().putIfAbsent(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey()));
        assertEquals(entry.getValue(), cache.getUnchecked(newKey));

        assertSame(entry.getValue(), cache.asMap().putIfAbsent(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().putIfAbsent(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey()));
        assertEquals(entry.getValue(), cache.getUnchecked(newKey));

      V newValue = remappingFunction.apply(entry.getValue().getValue(), value);
      if (newValue == null) {
        backingItr.remove();
      } else {
        entry.setValue(
            new RangeMapEntry<K, V>(
                entry.getValue().getLowerBound(), entry.getValue().getUpperBound(), newValue));
      }
    }

    entriesByLowerBound.putAll(gaps.build());

      return null;
    }
    alertListenerIfPresent(key, oldValue.getValue(), RemovalCause.REPLACED);
    return oldValue.getValue();
  }

  @CanIgnoreReturnValue
  @Override
  public V remove(Object key) {
    Timestamped<V> stamped = cachingHashMap.remove(key);
    if (stamped != null) {
      V value = stamped.getValue();
      // `key` was in the cache, so it's a K.

      Range<K> range, V value, @CheckForNull Entry<Cut<K>, RangeMapEntry<K, V>> entry) {
    if (entry != null
        && entry.getValue().getKey().isConnected(range)
        && entry.getValue().getValue().equals(value)) {
      return range.span(entry.getValue().getKey());
    }
    return range;
  }

  @Override
  public void putAll(RangeMap<K, ? extends V> rangeMap) {

        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override
        @ParametricNullness
        public V setValue(@ParametricNullness V value) {
          return ArrayMap.this.setValue(index, value);
        }
      };
    }

    @Override

        String title = DocumentUtil.getValue(document, fessConfig.getIndexFieldTitle(), String.class);
        if (StringUtil.isBlank(title)) {
            title = DocumentUtil.getValue(document, fessConfig.getIndexFieldFilename(), String.class);
            if (StringUtil.isBlank(title)) {
                title = DocumentUtil.getValue(document, fessConfig.getIndexFieldUrl(), String.class);
            }