// Start by looking for exact matches. We start at the leftmost label. For example, foo.bar.com
    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null
    for (i in domainLabelsUtf8Bytes.indices) {
      val rule = publicSuffixList.bytes.binarySearch(domainLabelsUtf8Bytes, i)
      if (rule != null) {
        exactMatch = rule

      executeListener(reversedList.runnable, reversedList.executor);
      reversedList = reversedList.next;
    }
  }

  /**
   * Submits the given runnable to the given {@link Executor} catching and logging all {@linkplain
   * RuntimeException runtime exceptions} thrown by the executor.
   */
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception

     * by sort order, creation time, regular name, and duplicate hostname.</p>
     *
     * @param duplicateHostPager the pager containing search criteria and pagination settings
     * @return a list of DuplicateHost entities matching the search criteria
     * @throws IllegalArgumentException if duplicateHostPager is null
     */
    public List<DuplicateHost> getDuplicateHostList(final DuplicateHostPager duplicateHostPager) {

			fpath = path.Join(bucket, obj.Key)
			if versions {
				fpath += ":" + obj.VersionID
			}
			return fpath
		}

		// List all objects from a bucket-name with a matching prefix.
		for object := range s3Client.ListObjects(context.Background(), bucket, opts) {
			if object.Err != nil {
				log.Println("FAILED: LIST with error:", object.Err)
				continue
			}

 * @author Nick Kralevich
 */
@GwtCompatible
@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class SingletonImmutableSet<E> extends ImmutableSet<E> {
  // We deliberately avoid caching the asList and hashCode here, to ensure that with
  // compressed oops, a SingletonImmutableSet packs all the way down to the optimal 16 bytes.

  final transient E element;

  SingletonImmutableSet(E element) {

    /**
     * Retrieves a paginated list of job logs based on the provided pager configuration.
     *
     * @param jobLogPager the pager configuration for pagination and filtering
     * @return a list of job logs matching the criteria
     */
    public List<JobLog> getJobLogList(final JobLogPager jobLogPager) {

        final PagingResultBean<JobLog> jobLogList = jobLogBhv.selectPage(cb -> {

### Remotely Inspecting backend data

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.smb.SmbFile;

/**
 * Manager for directory leases and caching
 */
public class DirectoryLeaseManager {

    private static final Logger log = LoggerFactory.getLogger(DirectoryLeaseManager.class);

    private final CIFSContext context;

         * Returns true if "cache" is present in the values or if there's a single "true" value
         * for backward compatibility.
         *
         * @return true if caching is enabled, false otherwise
         */
        public boolean isCache() {
            for (final String value : values) {
                if ("cache".equalsIgnoreCase(value)) {
                    return true;

/**
 * A builder of {@link LoadingCache} and {@link Cache} instances.
 *
 * <h2>Prefer <a href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a> over Guava's caching
 * API</h2>
 *
 * <p>The successor to Guava's caching API is <a
 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a