jdk-sandbox: comparison jdk/src/share/classes/java/nio/channels/FileLock.java

equal deleted inserted replaced

-:115e09b7a004
+:3acf8e5e2ca0
 /*
-* Copyright 2001 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 2001-2009 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 package java.nio.channels;
 import java.io.IOException;
 /**
 * A token representing a lock on a region of a file.
 *
 * <p> A file-lock object is created each time a lock is acquired on a file via
 * one of the {@link FileChannel#lock(long,long,boolean) lock} or {@link
-* FileChannel#tryLock(long,long,boolean) tryLock} methods of the {@link
+* FileChannel#tryLock(long,long,boolean) tryLock} methods of the
-* FileChannel} class.
+* {@link FileChannel} class, or the {@link
+* AsynchronousFileChannel#lock(long,long,boolean,Object,CompletionHandler) lock}
+* or {@link AsynchronousFileChannel#tryLock(long,long,boolean) tryLock}
+* methods of the {@link AsynchronousFileChannel} class.
 *
 * <p> A file-lock object is initially valid.  It remains valid until the lock
 * is released by invoking the {@link #release release} method, by closing the
 * channel that was used to acquire it, or by the termination of the Java
 * virtual machine, whichever comes first.  The validity of a lock may be
 * threads within the same virtual machine.
 *
 * <p> File-lock objects are safe for use by multiple concurrent threads.
 *
 *
-* <a name="pdep">
+* <a name="pdep"><h4> Platform dependencies </h4></a>
-* <h4> Platform dependencies </h4>
 *
 * <p> This file-locking API is intended to map directly to the native locking
 * facility of the underlying operating system.  Thus the locks held on a file
 * should be visible to all programs that have access to the file, regardless
 * of the language in which those programs are written.
 * it is strongly recommended that the locks provided by this API be used as if
 * they were advisory locks.
 *
 * <p> On some systems, acquiring a mandatory lock on a region of a file
 * prevents that region from being {@link java.nio.channels.FileChannel#map
-* </code>mapped into memory<code>}, and vice versa.  Programs that combine
+* <i>mapped into memory</i>}, and vice versa.  Programs that combine
 * locking and mapping should be prepared for this combination to fail.
 *
 * <p> On some systems, closing a channel releases all locks held by the Java
 * virtual machine on the underlying file regardless of whether the locks were
 * acquired via that channel or via another channel open on the same file.  It
 *
 *
 * @author Mark Reinhold
 * @author JSR-51 Expert Group
 * @since 1.4
+* @updated 1.7
 */
 public abstract class FileLock {
-private final FileChannel channel;
+private final Channel channel;
 private final long position;
 private final long size;
 private final boolean shared;
 /**
 this.size = size;
 this.shared = shared;
 }
 /**
-* Returns the file channel upon whose file this lock is held.  </p>
+* {@note new} Initializes a new instance of this class.
 *
-* @return  The file channel
+* @param  channel
+*         The channel upon whose file this lock is held
+*
+* @param  position
+*         The position within the file at which the locked region starts;
+*         must be non-negative
+*
+* @param  size
+*         The size of the locked region; must be non-negative, and the sum
+*         <tt>position</tt>&nbsp;+&nbsp;<tt>size</tt> must be non-negative
+*
+* @param  shared
+*         <tt>true</tt> if this lock is shared,
+*         <tt>false</tt> if it is exclusive
+*
+* @throws IllegalArgumentException
+*         If the preconditions on the parameters do not hold
+*
+* @since 1.7
+*/
+protected FileLock(AsynchronousFileChannel channel,
+long position, long size, boolean shared)
+{
+if (position < 0)
+throw new IllegalArgumentException("Negative position");
+if (size < 0)
+throw new IllegalArgumentException("Negative size");
+if (position + size < 0)
+throw new IllegalArgumentException("Negative position + size");
+this.channel = channel;
+this.position = position;
+this.size = size;
+this.shared = shared;
+}
+/**
+* {@note revised}
+* Returns the file channel upon whose file this lock was acquired.
+*
+* <p> This method has been superseded by the {@link #acquiredBy acquiredBy}
+* method.
+*
+* @return  The file channel, or {@code null} if the file lock was not
+*          acquired by a file channel.
 */
 public final FileChannel channel() {
+return (channel instanceof FileChannel) ? (FileChannel)channel : null;
+}
+/**
+* {@note new}
+* Returns the channel upon whose file this lock was acquired.
+*
+* @return  The channel upon whose file this lock was acquired.
+*
+* @since 1.7
+*/
+public Channel acquiredBy() {
 return channel;
 }
 /**
 * Returns the position within the file of the first byte of the locked

changeset 2057	3acf8e5e2ca0
parent 2	90ce3da70b43
child 3631	4dc04372d56b