* when there is a specific reason to prioritize memory over CPU.
 *
 * @author Louis Wasserman
 */
@J2ktIncompatible // no support for access-order mode in LinkedHashMap delegate
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends CompactHashMap<K, V> {

        ComponentUtil.getLdapManager().insert(role);

        roleBhv.insertOrUpdate(role, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a role.
     * @param role The role to delete.
     */
    public void delete(final Role role) {
        ComponentUtil.getLdapManager().delete(role);

        roleBhv.delete(role, op -> {

        : UndirectedGraphConnections.ofImmutable(
            Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
  }

  @Override
  BaseGraph<N> delegate() {
    return backingGraph;
  }

  /**
   * A builder for creating {@link ImmutableGraph} instances, especially {@code static final}
   * graphs. Example:
   *
   * {@snippet :

- **`CurlException`**: Unchecked RuntimeException for HTTP errors.

### I/O Layer

- **`ContentCache`**: In-memory or file-based caching. Implements `Closeable` and auto-deletes file cache on close.

- **`ContentOutputStream`**: Extends `DeferredFileOutputStream`. Writes to memory until threshold (default 1MB) exceeded, then spills to temp file.

## Technical Details

- **Java Version**: 17+

    String concurrentPackage = SettableFuture.class.getPackage().getName();
    ClassLoader classLoader = AbstractFutureFallbackAtomicHelperTest.class.getClassLoader();
    // we delegate to the current classloader so both loaders agree on classes like TestCase
    return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override

@GwtIncompatible
public final class LittleEndianDataInputStream extends FilterInputStream implements DataInput {

  /**
   * Creates a {@code LittleEndianDataInputStream} that wraps the given stream.
   *
   * @param in the stream to delegate to
   */
  public LittleEndianDataInputStream(InputStream in) {
    super(Preconditions.checkNotNull(in));
  }

  /** This method will throw an {@link UnsupportedOperationException}. */

  }

  private static class NonNavigableSortedSet extends ForwardingSortedSet<String> {
    private final SortedSet<String> delegate = Sets.newTreeSet();

    @Override
    protected SortedSet<String> delegate() {
      return delegate;
    }
  }

  public void testAsMapSorted() {
    SortedSet<String> strings = new NonNavigableSortedSet();

 *   <li>Thread Creation: Creates a group of crawler threads to perform the actual crawling.</li>
 *   <li>Execution: Starts the crawler threads and waits for them to complete.</li>
 *   <li>Cleanup: Deletes the crawled data and clears the URL filter.</li>
 * </ol>
 *
 * <p>The crawler can be configured with various parameters, such as the number of threads,
 * the maximum depth of crawling, and URL filters.
 *

        relatedContentBhv.insertOrUpdate(relatedContent, op -> op.setRefreshPolicy(Constants.TRUE));
        ComponentUtil.getRelatedContentHelper().update();
    }

    /**
     * Deletes a related content entity from the database.
     * After deletion, updates the related content helper to refresh the cache.
     *
     * @param relatedContent the RelatedContent entity to delete
     */

     */
    public void store(final RoleType roleType) {

        roleTypeBhv.insertOrUpdate(roleType, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a role type.
     * @param roleType The role type to delete.
     */
    public void delete(final RoleType roleType) {

        roleTypeBhv.delete(roleType, op -> {
            op.setRefreshPolicy(Constants.TRUE);