@ElementTypesAreNonnullByDefault
public abstract class FinalizableWeakReference<T> extends WeakReference<T>
    implements FinalizableReference {
  /**
   * Constructs a new finalizable weak reference.
   *
   * @param referent to weakly reference
   * @param queue that should finalize the referent
   */
  protected FinalizableWeakReference(@CheckForNull T referent, FinalizableReferenceQueue queue) {
    super(referent, queue.queue);
    queue.cleanUp();
  }

    /**
     * {@link ParseRuntimeException}を作成します。
     *
     * @param cause
     *            原因となった例外
     */
    public ParseRuntimeException(final ParseException cause) {
        super("ECL0050", asArray(cause), cause);
    }

    /**
     * {@link ParseRuntimeException}を作成します。
     *
     * @param s
     *            解析できなかった文字列
     */
    public ParseRuntimeException(final String s) {

    private String share; // Can be null

    private Address[] addresses;
    private int addressIndex;
    private int type;

    private CIFSContext ctx;


    /**
     * 
     * @param ctx
     * @param u
     */
    public SmbResourceLocatorImpl ( CIFSContext ctx, URL u ) {
        this.ctx = ctx;
        this.url = u;
    }


    /**
     * {@inheritDoc}
     *

    private final SmbFileHandleImpl handle;
    private final int filter;
    private final boolean recursive;


    /**
     * @param fh
     * @param filter
     * @param recursive
     * 
     */
    public SmbWatchHandleImpl ( SmbFileHandleImpl fh, int filter, boolean recursive ) {
        this.handle = fh;
        this.filter = filter;

   * argument count.
   *
   * <p>The returned list is serializable and implements {@link RandomAccess}.
   *
   * @param first the first element
   * @param second the second element
   * @param rest an array of additional elements, possibly empty
   * @return an unmodifiable list containing the specified elements
   */
  public static <E extends @Nullable Object> List<E> asList(

 * Implementations of this interface should avoid performing blocking calls or synchronizing on
 * shared resources.
 *
 * @param <K> the most general type of keys this listener can listen for; for example {@code Object}
 *     if any key is acceptable
 * @param <V> the most general type of values this listener can listen for; for example {@code
 *     Object} if any key is acceptable
 * @author Charles Fry
 * @since 10.0

    private Exception exception;
    private String message;
    private InputLocation location;

    /**
     * Create a new request with mandatory parameters.
     * @param severity
     * @param version
     */
    public ModelProblemCollectorRequest(Severity severity, Version version) {
        this.severity = Objects.requireNonNull(severity, "severity cannot be null");

import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Benchmarks for {@link CycleDetectingLockFactory}.
 *
 * @author Darick Tong
 */
public class CycleDetectingLockFactoryBenchmark {

  @Param({"2", "3", "4", "5", "10"})
  int lockNestingDepth;

  CycleDetectingLockFactory factory;

    private final CloseableIterator<FileEntry> delegate;
    private final ResourceFilter filter;
    private final SmbResource parent;
    private SmbResource next;


    /**
     * @param parent
     * @param delegate
     * @param filter
     * 
     */
    public FileEntryAdapterIterator ( SmbResource parent, CloseableIterator<FileEntry> delegate, ResourceFilter filter ) {
        this.parent = parent;

    private int lockSequenceNumber;
    private int lockSequenceIndex;
    private byte[] fileId;
    private final Smb2Lock[] locks;


    /**
     * @param config
     * @param fileId
     * @param locks
     */
    public Smb2LockRequest ( Configuration config, byte[] fileId, Smb2Lock[] locks ) {
        super(config, SMB2_LOCK);
        this.fileId = fileId;
        this.locks = locks;