import java.util.Map;
import java.util.Set;
import javax.annotation.CheckForNull;

/**
 * An implementation of {@link GraphConnections} for undirected graphs.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <V> Value parameter type
 */
@ElementTypesAreNonnullByDefault
final class UndirectedGraphConnections<N, V> implements GraphConnections<N, V> {
  private final Map<N, V> adjacentNodeValues;

     *
     * @param properties a collection of property maps to use for interpolation
     * @return a new {@link Options} instance with interpolated values
     */
    @Nonnull
    Options interpolate(@Nonnull Collection<Map<String, String>> properties);

    /**
     * Emits warning messages if deprecated options are used.
     *
     * @param printWriter the string consumer to use for output

    private int fileAttributes;
    private byte[] fileId = new byte[16];
    private CreateContextResponse[] createContexts;
    private final String fileName;


    /**
     * @param config
     * @param name
     */
    public Smb2CreateResponse ( Configuration config, String name ) {
        super(config);
        this.fileName = name;
    }


    /**
     * {@inheritDoc}
     *

 *
 */
public class Smb2TreeConnectRequest extends ServerMessageBlock2Request<Smb2TreeConnectResponse> {

    private int treeFlags;
    private String path;


    /**
     * @param config
     * @param path
     */
    public Smb2TreeConnectRequest ( Configuration config, String path ) {
        super(config, SMB2_TREE_CONNECT);
        this.path = path;
    }


    @Override

     * to find the POM file, else if no locator is provided, a file named 'pom.xml' needs to be
     * used by the requested model source.
     *
     * @param locator locator used to locate the pom file
     * @param relPath path of the requested model source relative to this model source POM
     * @return related model source or <code>null</code> if no such model source
     */

        return super.read(in);
    }

    public interface ContentTransformer {
        /**
         * Interpolate the value read from the xpp3 document
         *
         * @param source    the source value
         * @param fieldName a description of the field being interpolated. The implementation may use this to
         *                  log stuff
         * @return the interpolated value
         */

 * the License.
 */

package com.google.common.collect;

import static java.util.Arrays.sort;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

/**
 * A benchmark to determine the overhead of sorting with {@link Ordering#from(Comparator)}, or with

import static com.google.common.math.MathBenchmarking.randomPositiveDouble;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.math.RoundingMode;

/**
 * Benchmarks for the rounding methods of {@code DoubleMath}.
 *
 * @author Louis Wasserman
 */
public class DoubleMathRoundingBenchmark {

import javax.annotation.CheckForNull;

/**
 * An interface for representing and manipulating an origin node's adjacent nodes and incident edges
 * in a {@link Network}.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault
interface NetworkConnections<N, E> {

  Set<N> adjacentNodes();

  Set<N> predecessors();

  Set<N> successors();

   * Constructs a pattern file name filter object.
   *
   * @param patternStr the pattern string on which to filter file names
   * @throws PatternSyntaxException if pattern compilation fails (runtime)
   */
  public PatternFilenameFilter(String patternStr) {
    this(Pattern.compile(patternStr));
  }

  /**
   * Constructs a pattern file name filter object.
   *
   * @param pattern the pattern on which to filter file names
   */