* as a {@code List}:
 *
 * {@snippet :
 * ImmutableList<String> results =
 *     FluentIterable.from(database.getClientList())
 *         .filter(Client::isActiveInLastMonth)
 *         .transform(Object::toString)
 *         .limit(10)
 *         .toList();
 * }
 *
 * The approximate stream equivalent is:
 *
 * {@snippet :
 * List<String> results =
 *     database.getClientList()
 *         .stream()

import org.codelibs.fess.opensearch.config.exentity.CrawlingInfoParam;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.bhv.readable.EntityRowHandler;
import org.dbflute.cbean.result.ListResultBean;
import org.dbflute.cbean.result.PagingResultBean;
import org.dbflute.optional.OptionalEntity;

import com.orangesignal.csv.CsvConfig;
import com.orangesignal.csv.CsvReader;
import com.orangesignal.csv.CsvWriter;

							}
						} else if result.Online {
							offline = prev.offlineDuration
						}
					}
					lastOnline = prev.lastOnline
					if result.Online {
						lastOnline = time.Now()
					}
					l := prev.latency
					l.update(time.Since(start))
					m[result.Endpoint.Host] = epHealth{
						Endpoint:        result.Endpoint.Host,
						Scheme:          result.Endpoint.Scheme,

context.setMaxDepth(3);           // Max depth (-1 = unlimited)
context.setNumOfThread(10);       // Concurrent threads
```

### Accessing Results

```java
DataService ds = container.getComponent("dataService");

// Count
int count = ds.getCount(sessionId);

// Get by URL
AccessResult result = ds.getAccessResult(sessionId, url);

// Iterate all
ds.iterate(sessionId, accessResult -> {

    Map<Object, Object> result = cache.getAll(asList(lookupKeys));
    assertThat(result.keySet()).containsExactlyElementsIn(asList(lookupKeys));
    for (Entry<Object, Object> entry : result.entrySet()) {
      Object key = entry.getKey();
      Object value = entry.getValue();
      assertThat(result.get(key)).isSameInstanceAs(value);
      assertThat(result.get(value)).isNull();

         * results can exceed 2^63.
         */
        long result = times2ToThe32Mod(aHi * bHi /* < 2^62 */, m); // < m < 2^63
        result += aHi * bLo; // aHi * bLo < 2^63, result < 2^64
        if (result < 0) {
          result = UnsignedLongs.remainder(result, m);
        }
        // result < 2^63 again
        result += aLo * bHi; // aLo * bHi < 2^63, result < 2^64

     * This method creates a new function that caches the results of the original function,
     * improving performance for repeated calls with the same input.
     *
     * @param callback The original function to be memoized. It takes a String as input and returns a String.
     * @return A new {@code UnaryOperator<String>} that caches the results of the original function.

///

Whenever a new request arrives, **FastAPI** will take care of:

* Calling your dependency ("dependable") function with the correct parameters.
* Get the result from your function.
* Assign that result to the parameter in your *path operation function*.

```mermaid
graph TB

common_parameters(["common_parameters"])
read_items["/items/"]
read_users["/users/"]

 *   <li>Finally, natural ordering is used (i.e. the result of {@code Bar.compareTo(Bar)} is
 *       returned)
 * </ol>
 *
 * <p>Alas, {@link #reverse} is a little different. As you read backwards through a chain and
 * encounter a call to {@code reverse}, continue working backwards until a result is determined, and
 * then reverse that result.
 *
 * <h3>Additional notes</h3>
 *

        cb.query().addOrderBy_Term_Asc();
        cb.query().addOrderBy_CreatedTime_Asc();

        // search

    }

    /**
     * Retrieves a list of all available related content entities.
     * Results are ordered by term and limited by the configured maximum fetch size.
     *
     * @return a list of all available RelatedContent entities
     */
    public List<RelatedContent> getAvailableRelatedContentList() {