resource -> accessContextLogic.create(resource, OptionalThing::empty, OptionalThing::empty, () -> APP_TYPE));
    }

    /**
     * Sets the job class to be executed by this scheduler.
     *
     * @param jobClass the job class to set
     */
    public void setJobClass(final Class<? extends LaJob> jobClass) {
        this.jobClass = jobClass;
    }

     */
    protected abstract DictionaryFile<? extends DictionaryItem> newDictionaryFile(String id, String path, Date timestamp);

    /**
     * Sets the dictionary manager for this creator.
     *
     * @param dictionaryManager the dictionary manager to set
     */
    public void setDictionaryManager(final DictionaryManager dictionaryManager) {
        this.dictionaryManager = dictionaryManager;
    }

        }
    }

    /**
     * Gets the new stopword.
     *
     * @return The new stopword.
     */
    public String getNewInput() {
        return newInput;
    }

    /**
     * Sets the new stopword.
     *
     * @param newInput The new stopword.
     */
    public void setNewInput(final String newInput) {
        this.newInput = newInput;
    }

    /**
     * Gets the original stopword.

                }));
    }

    /**
     * Sets the user check interval.
     *
     * @param userCheckInterval The user check interval.
     */
    public void setUserCheckInterval(final long userCheckInterval) {
        this.userCheckInterval = userCheckInterval;
    }

    /**
     * Sets the user information cache size.
     *

      current.setValue(value);
    }
  }

  /** An {@code Iterator} over distinct keys in key head order. */
  private final class DistinctKeyIterator implements Iterator<K> {
    final Set<K> seenKeys = Sets.<K>newHashSetWithExpectedSize(keySet().size());
    @Nullable Node<K, V> next = head;
    @Nullable Node<K, V> current;
    int expectedModCount = modCount;

    private void checkForConcurrentModification() {

	}

	// Compute net policy change effect and updated policy mapping
	existingPolicySet := mp.policySet()
	policiesToUpdate := set.CreateStringSet(policies...)
	var newPolicySet set.StringSet
	newPolicyMapping := mp
	if isAttach {
		// new policies to attach => inputPolicies - existing (set difference)
		policiesToUpdate = policiesToUpdate.Difference(existingPolicySet)
		// validate that new policies to add are defined.

        } catch (final AutoBindingFailureException e) {
            logger.warn("DuplicateHostService is not found.", e);
        }
    }

    /**
     * Sets the list of duplicate host rules.
     *
     * @param duplicateHostList the list of duplicate host rules to use
     */
    public void setDuplicateHostList(final List<DuplicateHost> duplicateHostList) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static com.google.common.collect.Sets.unmodifiableNavigableSet;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

    protected boolean favoriteSupport;

    /** Flag indicating whether thumbnail generation is enabled. */
    protected boolean thumbnailSupport;

    /**
     * Hook method called before action execution. Sets up search-related flags and
     * registers popular words if enabled.
     *
     * @param runtime the action runtime context
     * @return the action response, or null to continue with normal processing
     */

    return generateTreeSet(freshElement);
  }

  @Generates
  static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement) {
    TreeSet<E> set = Sets.newTreeSet();
    set.add(freshElement);
    return set;
  }

  @Generates
  static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(
      E freshElement) {
    return ImmutableSortedSet.of(freshElement);
  }