}
            return entity;
        });
    }

    /**
     * Stores (inserts or updates) an elevate word and manages its associated label type mappings.
     *
     * @param elevateWord the elevate word entity to store
     */
    public void store(final ElevateWord elevateWord) {
        final boolean isNew = elevateWord.getId() == null;

	}

	if strings.HasSuffix(fh.Name, "/") {
		// Set the compression method to Store to ensure data length is truly zero,
		// which the writeHeader method always encodes for the size fields.
		// This is necessary as most compression formats have non-zero lengths
		// even when compressing an empty string.
		fh.Method = Store
		fh.Flags &^= 0x8 // we will not write a data descriptor

 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs
 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,

                    final float score = 1.0f / (rankConstant + j);
                    if (scoreDocMap.containsKey(id)) {
                        final Map<String, Object> baseDoc = scoreDocMap.get(id);
                        final float oldScore = toFloat(baseDoc.get(scoreField));
                        baseDoc.put(scoreField, oldScore + score);

    implements Table<R, C, @Nullable V>, Serializable {

  /**
   * Creates an {@code ArrayTable} filled with {@code null}.
   *
   * @param rowKeys row keys that may be stored in the generated table
   * @param columnKeys column keys that may be stored in the generated table
   * @throws NullPointerException if any of the provided keys is null
   * @throws IllegalArgumentException if {@code rowKeys} or {@code columnKeys} contains duplicates

  /**
   * Stores all key-value pairs of {@code multimap} in this multimap, in the order returned by
   * {@code multimap.entries()}.
   *
   * @return {@code true} if the multimap changed
   */
  @CanIgnoreReturnValue
  boolean putAll(Multimap<? extends K, ? extends V> multimap);

  /**

            if (url != null) {
                return url;
            }
            return id;
        }
    }

    /**
     * Statistics data object that stores timestamped events and maintains reference counting.
     * Extends LinkedHashMap to store event names mapped to their timestamps.
     * Includes reference counting for multi-threaded access tracking.
     */

        if (logger.isDebugEnabled()) {
            logger.debug("redirect to: {} (using {} endpoint)", authUrl, useV2Endpoint ? "v2.0" : "v1.0");
        }
        return authUrl;

    }

    /**
     * Stores state and nonce information in the HTTP session.
     * @param session The HTTP session.
     * @param state The OAuth2 state parameter.
     * @param nonce The OpenID Connect nonce parameter.
     */

   * equivalent to RegularImmutableSet, save that instead of having a hash table containing the
   * elements directly and null for empty positions, we store indices of the keys in the hash table,
   * and ABSENT for empty positions.  We then look up the keys in alternatingKeysAndValues.
   *
   * (The index actually stored is the index of the key in alternatingKeysAndValues, which is
   * double the index of the entry in entrySet.asList.)
   *

     * setException(stackOverflowError) would fail:
     *
     * - If the stack overflowed before set()/setValue() could even store the result in the output
     * Future, then a call setException() would likely also overflow.
     *
     * - If the stack overflowed after set()/setValue() stored its result, then a call to
     * setException() will be a no-op because the Future is already done.
     *