* char[])}.
   *
   * @since 2.0
   */
  public static Comparator<char[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }

  private enum LexicographicalComparator implements Comparator<char[]> {
    INSTANCE;

    @Override
    public int compare(char[] left, char[] right) {
      int minLength = Math.min(left.length, right.length);
      for (int i = 0; i < minLength; i++) {

 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public abstract class ImmutableMultimap<K, V> extends BaseImmutableMultimap<K, V>
    implements Serializable {

  /**
   * Returns an empty multimap.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  public static <K, V> ImmutableMultimap<K, V> of() {

 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * @author Jared Levy
 */
@GwtCompatible
class StandardTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable {
  final Map<R, Map<C, V>> backingMap;
  final Supplier<? extends Map<C, V>> factory;

  StandardTable(Map<R, Map<C, V>> backingMap, Supplier<? extends Map<C, V>> factory) {
    this.backingMap = backingMap;

     * This class handles the process of writing changes to a temporary file
     * and then replacing the original file upon successful commit.
     */
    protected class SynonymUpdater implements Closeable {

        /** A flag indicating whether the changes have been committed. */
        protected boolean isCommit = false;

        /** The temporary file to write changes to. */

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// Package cmd This file implements helper functions to validate AWS
// Signature Version '4' authorization header.
//
// This package provides comprehensive helpers for following signature
// types.
// - Based on Authorization header.

    }
    return map;
  }

  static <T> Comparator<T> arbitraryNullFriendlyComparator() {
    return new NullFriendlyComparator<>();
  }

  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
    @Override
    public int compare(T left, T right) {
      return String.valueOf(left).compareTo(String.valueOf(right));
    }
  }

          .asList()
          .subList(1, elements.length + 1);
    }
  }

  public abstract static class TestUnhashableSetGenerator
      extends TestUnhashableCollectionGenerator<Set<UnhashableObject>>
      implements TestSetGenerator<UnhashableObject> {}

  private static Ordering<String> createExplicitComparator(String[] elements) {
    // Collapse equal elements, which Ordering.explicit() doesn't support, while

 */
/**
 * An HTTP servlet filter that provides NTLM authentication support.
 * This filter allows web applications to authenticate users via NTLM/Windows authentication.
 */
@Deprecated
public class NtlmHttpFilter implements Filter {

    /**
     * Default constructor.
     */
    public NtlmHttpFilter() {
        // Default constructor
    }

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

 * of the created or opened file or directory.
 *
 * @author mbechler
 *
 */
public class Smb2CreateResponse extends ServerMessageBlock2Response implements SmbBasicFileInfo {

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

    private byte oplockLevel;
    private byte openFlags;
    private int createAction;

import org.codehaus.plexus.logging.AbstractLogEnabled;

/**
 */
@Named
@Singleton
@Deprecated
public class DefaultRepositoryMetadataManager extends AbstractLogEnabled implements RepositoryMetadataManager {
    @Inject
    private WagonManager wagonManager;

    @Inject
    private UpdateCheckManager updateCheckManager;

    @Override
    public void resolve(