* @param resource the resource to track
     * @return resource ID for tracking
     */
    public String registerResource(AutoCloseable resource) {
        if (resource == null) {
            throw new IllegalArgumentException("Resource cannot be null");
        }

        String resourceId = generateResourceId(resource);
        ResourceHolder holder = new ResourceHolder(resourceId, resource, referenceQueue);

            if (synonymMap != null && synonymMap.fst == null) {
                this.synonymMap = null;
            }
        } else {
            this.synonymLoader = null;
        }
        if (synonymMap != null) {
            this.fst = synonymMap.fst;
            this.fstReader = fst.getBytesReader();
            scratchArc = new FST.Arc<>();
        }

        ch = 0;

                            "title": "Email",
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "full_name": {
                            "title": "Full Name",
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "disabled": {
                            "title": "Disabled",

            }
        }

        list.addAll(fileList);
        return list;
    }

    /**
     * Extracts the file name from a full object path.
     *
     * @param objectName the full object path
     * @return the file name portion of the path
     */
    private static String getName(final String objectName) {
        final String[] values = objectName.split("/");

                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "price": {"title": "Price", "type": "number"},
                        "tax": {
                            "title": "Tax",
                            "anyOf": [{"type": "number"}, {"type": "null"}],
                        },
                    },
                },

   */
  @Nullable V getLiveValue(ReferenceEntry<K, V> entry, long now) {
    if (entry.getKey() == null) {
      return null;
    }
    V value = entry.getValueReference().get();
    if (value == null) {
      return null;
    }

    if (isExpired(entry, now)) {
      return null;
    }
    return value;
  }

  // expiration

    while (added < numElements) {
      // we could rely solely on #poll, but #drainTo might be more efficient when there are multiple
      // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
      added += q.drainTo(buffer, numElements - added);
      if (added < numElements) { // not enough elements immediately available; will have to poll
        E e = q.poll(deadline - System.nanoTime(), NANOSECONDS);
        if (e == null) {

     * allowing the CAS below to succeed.
     */
    Thread currentThread = Thread.currentThread();
    if (!compareAndSet(null, currentThread)) {
      return; // someone else has run or is running.
    }

    boolean run = !isDone();
    T result = null;
    Throwable error = null;
    try {
      if (run) {
        result = runInterruptibly();

  private val key: String

  /** Non-null for client web sockets. These can be canceled. */
  internal var call: Call? = null

  /** This task processes the outgoing queues. Call [runWriter] to after enqueueing. */
  private var writerTask: Task? = null

  /** Null until this web socket is connected. Only accessed by the reader thread. */
  private var reader: WebSocketReader? = null

                    }
                }
                exception = null;
                break;
            } catch (final Exception e) {
                exception = new SuggesterException(e);
                scrollId = null;
            }
        }

        docCount.getAndAdd(queue.size());

        if (exception != null) {
            throw exception;
        }
    }

    /**