* log it.
   *
   * @param flushable the {@code Flushable} object to be flushed.
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code flush}
   *     method
   * @throws IOException if {@code swallowIOException} is false and {@link Flushable#flush} throws
   *     an {@code IOException}.
   * @see Closeables#close
   */

   * enough precision.
   */
  private static final long C1 = 0xcc9e2d51;
  private static final long C2 = 0x1b873593;

  /*
   * This method was rewritten in Java from an intermediate step of the Murmur hash function in
   * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp, which contained the
   * following header:
   *

    }

    ///// CycleDetectingLock methods. /////

    @Override
    public LockGraphNode getLockGraphNode() {
      return lockGraphNode;
    }

    @Override
    public boolean isAcquiredByCurrentThread() {
      return isHeldByCurrentThread();
    }

    ///// Overridden ReentrantLock methods. /////

    @Override
    public void lock() {

 * application data - do we need a dictionary for our applications like Apple does. We could easily
 * hook into this and this is the model we need to follow - how many of our REST services do not map
 * directory to a method in the application interface?
 *
 * - research extension points versus plugins
 *
 * from igor: two plugins A and B, both depend on the same library but use different versions, say

    /**
     * @param property the property to check
     * @return <code>true</code> if this is a valid property for this processor
     */
    boolean isValidProperty(String property);

    /**
     * This method is responsible for examining the request and possibly overwrite of the valid properties in the model
     *
     * @param modelProperties
     * @param request
     */

import okhttp3.ExperimentalOkHttpApi

/** Handler for mock server requests. */
@ExperimentalOkHttpApi
abstract class Dispatcher {
  /**
   * Returns a response to satisfy `request`. This method may block (for instance, to wait on
   * a CountdownLatch).
   */
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  /**

    int i = 0;
    for (Object e : elements) {
      array[i++] = (Character) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */
  protected abstract List<Character> create(Character[] elements);

  @Override
  public Character[] createArray(int length) {
    return new Character[length];

package com.google.common.collect;

import java.util.Collection;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A GWT-only class only used by GWT emulations. It is used to consolidate the definitions of method
 * delegation to save code size.
 *
 * @author Hayward Chan
 */
// TODO: Make this class GWT serializable.
@ElementTypesAreNonnullByDefault
class ForwardingImmutableCollection<E> extends ImmutableCollection<E> {

            authHeader = "Proxy-Authenticate";
            authProperty = "Proxy-Authorization";
        }
        String authorization = null;
        List methods = (List) getHeaderFields0().get(authHeader);
        if (methods == null) return null;
        Iterator iterator = methods.iterator();
        while (iterator.hasNext()) {
            String currentAuthMethod = (String) iterator.next();

import javax.annotation.CheckForNull;

/**
 * An extension of {@code DataInput} for reading from in-memory byte arrays; its methods offer
 * identical functionality but do not throw {@link IOException}.
 *
 * <p><b>Warning:</b> The caller is responsible for not attempting to read past the end of the
 * array. If any method encounters the end of the array prematurely, it throws {@link