// Attribute
    // =========

    /** Client for interacting with the search engine. */
    @Resource
    protected SearchEngineClient searchEngineClient;

    /** Helper for building and parsing search queries. */
    @Resource
    protected QueryHelper queryHelper;

    /** Helper for executing search operations. */
    @Resource
    protected SearchHelper searchHelper;

    // Standard lease states apply, plus directory-specific semantics:
    
    // READ_CACHING for directories means:
    // - Can cache directory enumeration results
    // - Can cache file existence queries
    // - Can cache basic file attributes
    
    // HANDLE_CACHING for directories means:
    // - Can keep directory handle open
    // - Can cache subdirectory handles
    

          }
        });
  }

  /**
   * An immutable snapshot of the current state of the service. This class represents a consistent
   * snapshot of the state and therefore it can be used to answer simple queries without needing to
   * grab a lock.
   */
  // @Immutable except that Throwable is mutable (initCause(), setStackTrace(), mutable subclasses).
  private static final class StateSnapshot {
    /**

        }
        return childUrlSet;
    }

    /**
     * Retrieves child URLs for a given document ID from the search engine index.
     * This method queries the search engine for child documents and extracts their URLs.
     *
     * @param searchEngineClient the search engine client to query
     * @param id the parent document ID to find children for

                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

    }

    /**
     * Gets the count of currently running crawler jobs.
     * This method queries the scheduled jobs to count active crawler processes.
     * Used to enforce maximum concurrent crawler limits.
     *
     * @return the number of currently running crawler jobs
     */

labels.prev_page=Prev
labels.next_page=Next
labels.did_not_match=Your search - <b>{0}</b> - did not match any documents.
labels.search_title=Fess
labels.search_popular_word_word=Popular Words:
labels.search_related_queries=Related Queries:
labels.search_result_select_sort=-  Sort  -
labels.search_result_select_num=- Display Count -
labels.search_result_sort_score_desc=by Score
labels.search_result_sort_filename_asc=by Filename (asc)

                }
                throw new UnknownHostException(addr.toString());
            }
            if (response.received && response.resultCode == 0) {

                /* For name queries resolved by different sources (e.g. WINS,
                 * BCAST, Node Status) we need to augment the hashcode generated
                 * for the addresses hostname or failed lookups for one type will

    return new ImmutableSortedMap<K, V>(delegate, comparator);
  }

  /*
   * We don't permit nulls, but we wrap every comparator with nullsFirst().
   * Why? We want for queries like containsKey(null) to return false, but the
   * GWT SortedMap implementation that we delegate to throws
   * NullPointerException if the comparator does. Since our construction

        protected long requestedTime;
        /**
         * The list of facet fields and their values.
         */
        protected List<Map<String, Object>> facetField;
        /**
         * The list of facet queries and their counts.
         */
        protected List<Map<String, Object>> facetQuery;

        /**
         * Populates this response with search render data.

   * enter this monitor. This method is designed primarily for use in monitoring of the system
   * state.
   */
  public boolean hasQueuedThreads() {
    return lock.hasQueuedThreads();
  }

  /**
   * Queries whether the given thread is waiting to enter this monitor. Note that because
   * cancellations may occur at any time, a {@code true} return does not guarantee that this thread