--- a/ChangeLog	Fri Mar 06 12:26:40 2009 +0000
+++ b/ChangeLog	Fri Mar 06 13:04:03 2009 +0000
@@ -1,3 +1,299 @@
+2009-03-06  Andrew John Hughes  <ahughes@redhat.com>
+
+	* overlays/nio2/openjdk/jdk/make/mksample/nio/file/Makefile,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousByteChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannelGroup.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousDatagramChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousFileChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/CompletionHandler.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/SeekableByteChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/spi/AsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AccessDeniedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AccessMode.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AtomicMoveNotSupportedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedDirectoryStreamException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedWatchServiceException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/CopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryNotEmptyException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryStreamFilters.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileAction.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileRef.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileStore.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystems.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileTreeWalker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitResult.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Files.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/InvalidPathException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/LinkOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/LinkPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NoSuchFileException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NotDirectoryException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NotLinkException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/OpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Path.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/PathMatcher.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Paths.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ProviderMismatchException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ProviderNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ReadOnlyFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/SecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/SimpleFileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardWatchEventKind.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchEvent.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Watchable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntry.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryFlag.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryType.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/Attributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/BasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/BasicFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/DosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/DosFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileOwnerAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreSpaceAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/GroupPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFilePermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFilePermissions.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipalLookupService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipalNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/AbstractPath.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/FileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/FileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AbstractFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousChannelGroupImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Cancellable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/CompletedFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/FileLockTable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Groupable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Invoker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/PendingFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousDatagramChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/ThreadPool.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractPoller.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Cancellable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/FileOwnerAttributeViewImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Globs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/MimeType.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/NativeBuffer.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/NativeBuffers.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/PollingWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Reflect.java,
+	* overlays/nio2/openjdk/jdk/src/share/native/sun/nio/ch/genSocketOptionRegistry.c,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/AclEdit.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Chmod.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Copy.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/DiskUsage.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/FileType.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/WatchDir.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Xdd.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/EPollPort.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/LinuxAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/Port.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisEventPort.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/GnomeFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxDosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixChannelFactory.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixException.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileKey.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileModeAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileStoreAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixMountEntry.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixSecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixUriUtils.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixUserPrincipals.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/EPollPort.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/SolarisEventPort.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/UnixAsynchronousSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/GnomeFileTypeDetector.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/LinuxNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/SolarisNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/SolarisWatchService.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/UnixCopyFile.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/UnixNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/genSolarisConstants.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/genUnixConstants.c,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/DefaultSelectorProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/Iocp.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/PendingIoCache.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/DefaultFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/DefaultFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/RegistryFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsConstants.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsException.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributeViews.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileCopy.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsLinkSupport.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPath.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPathParser.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPathType.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsSecurity.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsSecurityDescriptor.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsUriSupport.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsUserPrincipals.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/Iocp.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousFileChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousServerSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/fs/RegistryFileTypeDetector.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/fs/WindowsNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/AsExecutor.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/Attack.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/GroupOfOne.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/Identity.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/PrivilegedThreadFactory.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/Restart.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/Unbounded.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousChannelGroup/run_any_task.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousDatagramChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousFileChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousFileChannel/CustomThreadPool.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousFileChannel/Lock.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousFileChannel/MyThreadFactory.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousServerSocketChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousServerSocketChannel/WithSecurityManager.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousServerSocketChannel/java.policy.allow,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousServerSocketChannel/java.policy.deny,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousSocketChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/AsynchronousSocketChannel/Leaky.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/Channels/Basic2.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/spi/AsynchronousChannelProvider/CheckProvider.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/spi/AsynchronousChannelProvider/META-INF/services/java.nio.channels.spi.AsynchronousChannelProvider,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/spi/AsynchronousChannelProvider/Provider1.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/spi/AsynchronousChannelProvider/Provider2.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/channels/spi/AsynchronousChannelProvider/custom_provider.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/DirectoryStream/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/DirectoryStream/Filters.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/DirectoryStream/SecureDS.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/FileStore/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/FileSystem/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/ContentType.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/CreateFileTree.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/ForceLoad.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/META-INF/services/java.nio.file.spi.FileTypeDetector,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/Misc.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/PrintFileTree.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/SimpleFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/SkipSiblings.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/TerminateWalk.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/content_type.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Files/walk_file_tree.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/CopyAndMove.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/DeleteOnClose.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/InterruptCopy.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/Links.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/Misc.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/PathOps.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/SBC.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/TemporaryFiles.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/UriImportExport.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/delete_on_close.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/Path/temporary_files.sh,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/PathMatcher/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/TestUtil.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/FileTreeModifier.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/WithSecurityManager.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/denyAll.policy,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/grantDirAndOneLevel.policy,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/grantDirAndTree.policy,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/WatchService/grantDirOnly.policy,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/AclFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/Attributes/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/BasicFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/DosFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/FileStoreAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/attribute/PosixFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/spi/SetDefaultProvider.java,
+	* overlays/nio2/openjdk/jdk/test/java/nio/file/spi/TestProvider.java:
+	Removed; in b50.
+	* Makefile.am: Bump to b50.
+
 2009-03-06  Andrew John Hughes  <ahughes@redhat.com>
 
 	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/io/Inputs/Basic.java,

--- a/Makefile.am	Fri Mar 06 12:26:40 2009 +0000
+++ b/Makefile.am	Fri Mar 06 13:04:03 2009 +0000
@@ -1,6 +1,6 @@
-OPENJDK_DATE = 26_feb_2009
-OPENJDK_MD5SUM = 2401015f65b5c099acf87b3f0b9e8404
-OPENJDK_VERSION = b49
+OPENJDK_DATE = 05_mar_2009
+OPENJDK_MD5SUM = a451251ebdd9a219b16429369fa72e2a
+OPENJDK_VERSION = b50
 
 CACAO_VERSION = 0.99.3
 CACAO_MD5SUM = 80de3ad344c1a20c086ec5f1390bd1b8

--- a/overlays/nio2/openjdk/jdk/make/mksample/nio/file/Makefile	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-#
-# Copyright 2007 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
-# particular file as subject to the "Classpath" exception as provided
-# by Sun in the LICENSE file that accompanied this code.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-# version 2 for more details (a copy is included in the LICENSE file that
-# accompanied this code).
-#
-# You should have received a copy of the GNU General Public License version
-# 2 along with this work; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
-# CA 95054 USA or visit www.sun.com if you need additional information or
-# have any questions.
-#
-
-#
-# Makefile for the nio/file sample code
-#
-
-BUILDDIR = ../../..
-
-PRODUCT = java
-
-include $(BUILDDIR)/common/Defs.gmk
-
-SAMPLE_SRC_DIR = $(SHARE_SRC)/sample/nio/file
-SAMPLE_DST_DIR = $(SAMPLEDIR)/nio/file
-
-SAMPLE_FILES =							\
-	$(SAMPLE_DST_DIR)/AclEdit.java				\
-	$(SAMPLE_DST_DIR)/Chmod.java				\
-	$(SAMPLE_DST_DIR)/Copy.java				\
-	$(SAMPLE_DST_DIR)/DiskUsage.java			\
-	$(SAMPLE_DST_DIR)/FileType.java				\
-	$(SAMPLE_DST_DIR)/WatchDir.java				\
-	$(SAMPLE_DST_DIR)/Xdd.java
-
-all build: $(SAMPLE_FILES)
-
-$(SAMPLE_DST_DIR)/%: $(SAMPLE_SRC_DIR)/%
-	$(install-file)
-
-clean clobber:
-	$(RM) -r $(SAMPLE_DST_DIR)
-
-.PHONY: all build clean clobber

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package com.sun.nio.file;
-
-import java.nio.file.CopyOption;
-
-/**
- * Defines <em>extended</em> copy options supported on some platforms
- * by Sun's provider implementation.
- *
- * @since 1.7
- */
-
-public enum ExtendedCopyOption implements CopyOption {
-    /**
-     * The copy may be interrupted by the {@link Thread#interrupt interrupt}
-     * method.
-     */
-    INTERRUPTIBLE,
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package com.sun.nio.file;
-
-import java.nio.file.OpenOption;
-
-/**
- * Defines <em>extended</em> open options supported on some platforms
- * by Sun's provider implementation.
- *
- * @since 1.7
- */
-
-public enum ExtendedOpenOption implements OpenOption {
-    /**
-     * Prevent operations on the file that request read access.
-     */
-    NOSHARE_READ,
-    /**
-     * Prevent operations on the file that request write access.
-     */
-    NOSHARE_WRITE,
-    /**
-     * Prevent operations on the file that request delete access.
-     */
-    NOSHARE_DELETE;
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package com.sun.nio.file;
-
-import java.nio.file.WatchEvent.Modifier;
-
-/**
- * Defines <em>extended</em> watch event modifiers supported on some platforms
- * by Sun's provider implementation.
- *
- * @since 1.7
- */
-
-public enum ExtendedWatchEventModifier implements Modifier {
-
-    /**
-     * Register a file tree instead of a single directory.
-     */
-    FILE_TREE,
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousByteChannel.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,206 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.nio.ByteBuffer;
-import java.util.concurrent.Future;
-
-/**
- * An asynchronous channel that can read and write bytes.
- *
- * <p> Some channels may not allow more than one read to be outstanding at any
- * given time. If a thread invokes a read method before a previous read
- * operation has completed then a {@link ReadPendingException} will be thrown.
- * Similarly, if a write method is invoked before a previous write has completed
- * then {@link WritePendingException} is thrown. Whether or not other kinds of
- * I/O operations may proceed concurrently with a read operation depends upon
- * the type of the channel.
- *
- * <p> Note that {@link java.nio.ByteBuffer ByteBuffers} are not safe for use by
- * multiple concurrent threads. When a read or write operation is initiated then
- * care must be taken to ensure that the buffer is not accessed until the
- * operation completes.
- *
- * @see Channels#newInputStream(AsynchronousByteChannel)
- * @see Channels#newOutputStream(AsynchronousByteChannel)
- *
- * @since 1.7
- */
-
-public interface AsynchronousByteChannel
-    extends AsynchronousChannel
-{
-    /**
-     * Reads a sequence of bytes from this channel into the given buffer.
-     *
-     * <p> This method initiates an operation to read a sequence of bytes from
-     * this channel into the given buffer. The method returns a {@link Future}
-     * representing the pending result of the operation. The result of the
-     * operation, obtained by invoking the {@code Future} 's {@link
-     * Future#get() get} method, is the number of bytes read or {@code -1} if
-     * all bytes have been read and the channel has reached end-of-stream.
-     *
-     * <p> This method initiates a read operation to read up to <i>r</i> bytes
-     * from the channel, where <i>r</i> is the number of bytes remaining in the
-     * buffer, that is, {@code dst.remaining()} at the time that the read is
-     * attempted. Where <i>r</i> is 0, the read operation completes immediately
-     * with a result of {@code 0} without initiating an I/O operation.
-     *
-     * <p> Suppose that a byte sequence of length <i>n</i> is read, where
-     * <tt>0</tt>&nbsp;<tt>&lt;</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
-     * This byte sequence will be transferred into the buffer so that the first
-     * byte in the sequence is at index <i>p</i> and the last byte is at index
-     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>,
-     * where <i>p</i> is the buffer's position at the moment the read is
-     * performed. Upon completion the buffer's position will be equal to
-     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
-     *
-     * <p> Buffers are not safe for use by multiple concurrent threads so care
-     * should be taken to not to access the buffer until the operaton has completed.
-     *
-     * <p> This method may be invoked at any time. Some channel types may not
-     * allow more than one read to be outstanding at any given time. If a thread
-     * initiates a read operation before a previous read operation has
-     * completed then a {@link ReadPendingException} will be thrown.
-     *
-     * <p> The <tt>handler</tt> parameter is used to specify a {@link
-     * CompletionHandler}. When the read operation completes the handler's
-     * {@link CompletionHandler#completed completed} method is executed.
-     *
-     *
-     * @param   dst
-     *          The buffer into which bytes are to be transferred
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The completion handler object; can be {@code null}
-     *
-     * @return  A Future representing the result of the operation
-     *
-     * @throws  IllegalArgumentException
-     *          If the buffer is read-only
-     * @throws  ReadPendingException
-     *          If the channel does not allow more than one read to be outstanding
-     *          and a previous read has not completed
-     */
-    <A> Future<Integer> read(ByteBuffer dst,
-                             A attachment,
-                             CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * Reads a sequence of bytes from this channel into the given buffer.
-     *
-     * <p> An invocation of this method of the form <tt>c.read(dst)</tt>
-     * behaves in exactly the same manner as the invocation
-     * <blockquote><pre>
-     * c.read(dst, null, null);</pre></blockquote>
-     *
-     * @param   dst
-     *          The buffer into which bytes are to be transferred
-     *
-     * @return  A Future representing the result of the operation
-     *
-     * @throws  IllegalArgumentException
-     *          If the buffer is read-only
-     * @throws  ReadPendingException
-     *          If the channel does not allow more than one read to be outstanding
-     *          and a previous read has not completed
-     */
-    Future<Integer> read(ByteBuffer dst);
-
-    /**
-     * Writes a sequence of bytes to this channel from the given buffer.
-     *
-     * <p> This method initiates an operation to write a sequence of bytes to
-     * this channel from the given buffer. This method returns a {@link
-     * Future} representing the pending result of the operation. The result
-     * of the operation, obtained by invoking the <tt>Future</tt>'s {@link
-     * Future#get() get} method, is the number of bytes written, possibly zero.
-     *
-     * <p> This method initiates a write operation to write up to <i>r</i> bytes
-     * to the channel, where <i>r</i> is the number of bytes remaining in the
-     * buffer, that is, {@code src.remaining()}  at the moment the write is
-     * attempted. Where <i>r</i> is 0, the write operation completes immediately
-     * with a result of {@code 0} without initiating an I/O operation.
-     *
-     * <p> Suppose that a byte sequence of length <i>n</i> is written, where
-     * <tt>0</tt>&nbsp;<tt>&lt;</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
-     * This byte sequence will be transferred from the buffer starting at index
-     * <i>p</i>, where <i>p</i> is the buffer's position at the moment the
-     * write is performed; the index of the last byte written will be
-     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>.
-     * Upon completion the buffer's position will be equal to
-     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
-     *
-     * <p> Buffers are not safe for use by multiple concurrent threads so care
-     * should be taken to not to access the buffer until the operaton has completed.
-     *
-     * <p> This method may be invoked at any time. Some channel types may not
-     * allow more than one write to be outstanding at any given time. If a thread
-     * initiates a write operation before a previous write operation has
-     * completed then a {@link WritePendingException} will be thrown.
-     *
-     * <p> The <tt>handler</tt> parameter is used to specify a {@link
-     * CompletionHandler}. When the write operation completes the handler's
-     * {@link CompletionHandler#completed completed} method is executed.
-     *
-     * @param   src
-     *          The buffer from which bytes are to be retrieved
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The completion handler object; can be {@code null}
-     *
-     * @return  A Future representing the result of the operation
-     *
-     * @throws  WritePendingException
-     *          If the channel does not allow more than one write to be outstanding
-     *          and a previous write has not completed
-     */
-    <A> Future<Integer> write(ByteBuffer src,
-                              A attachment,
-                              CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * Writes a sequence of bytes to this channel from the given buffer.
-     *
-     * <p> An invocation of this method of the form <tt>c.write(src)</tt>
-     * behaves in exactly the same manner as the invocation
-     * <blockquote><pre>
-     * c.write(src, null, null);</pre></blockquote>
-     *
-     * @param   src
-     *          The buffer from which bytes are to be retrieved
-     *
-     * @return A Future representing the result of the operation
-     *
-     * @throws  WritePendingException
-     *          If the channel does not allow more than one write to be outstanding
-     *          and a previous write has not completed
-     */
-    Future<Integer> write(ByteBuffer src);
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannel.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,118 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.io.IOException;
-import java.nio.channels.Channel;
-import java.util.concurrent.Future;  // javadoc
-
-/**
- * A channel that supports asynchronous I/O operations. Asynchronous I/O
- * operations will usually take one of two forms:
- *
- * <ol>
- * <li><pre>{@link Future}&lt;V&gt; <em>operation</em>(<em>...</em>)</pre></li>
- * <li><pre>Future&lt;V&gt; <em>operation</em>(<em>...</em> A attachment, {@link CompletionHandler}&lt;V,? super A&gt handler)</pre></li>
- * </ol>
- *
- * where <i>operation</i> is the name of the I/O operation (read or write for
- * example), <i>V</i> is the result type of the I/O operation, and <i>A</i> is
- * the type of an object attached to the I/O operation to provide context when
- * consuming the result. The attachment is important for cases where a
- * <em>state-less</em> {@code CompletionHandler} is used to consume the result
- * of many I/O operations.
- *
- * <p> In the first form, the methods defined by the {@link Future Future}
- * interface may be used to check if the operation has completed, wait for its
- * completion, and to retrieve the result. In the second form, a {@link
- * CompletionHandler} is invoked to consume the result of the I/O operation when
- * it completes, fails, or is cancelled.
- *
- * <p> A channel that implements this interface is <em>asynchronously
- * closeable</em>: If an I/O operation is outstanding on the channel and the
- * channel's {@link #close close} method is invoked, then the I/O operation
- * fails with the exception {@link AsynchronousCloseException}.
- *
- * <p> Asynchronous channels are safe for use by multiple concurrent threads.
- * Some channel implementations may support concurrent reading and writing, but
- * may not allow more than one read and one write operation to be outstanding at
- * any given time.
- *
- * <h4>Cancellation</h4>
- *
- * <p> The {@code Future} interface defines the {@link Future#cancel cancel}
- * method to cancel execution of a task.
- *
- * <p> Where the {@code cancel} method is invoked with the {@code
- * mayInterruptIfRunning} parameter set to {@code true} then the I/O operation
- * may be interrupted by closing the channel. This will cause any other I/O
- * operations outstanding on the channel to complete with the exception {@link
- * AsynchronousCloseException}.
- *
- * <p> If a {@code CompletionHandler} is specified when initiating an I/O
- * operation, and the {@code cancel} method is invoked to cancel the I/O
- * operation before it completes, then the {@code CompletionHandler}'s {@link
- * CompletionHandler#cancelled cancelled} method is invoked.
- *
- * <p> If an implementation of this interface supports a means to cancel I/O
- * operations, and where cancellation may leave the channel, or the entity to
- * which it is connected, in an inconsistent state, then the channel is put into
- * an implementation specific <em>error state</em> that prevents further
- * attempts to initiate I/O operations on the channel. For example, if a read
- * operation is cancelled but the implementation cannot guarantee that bytes
- * have not been read from the channel then it puts the channel into error state
- * state; further attempts to initiate a {@code read} operation causes an
- * unspecified runtime exception to be thrown.
- *
- * <p> Where the {@code cancel} method is invoked to cancel read or write
- * operations then it recommended that all buffers used in the I/O operations be
- * discarded or care taken to ensure that the buffers are not accessed while the
- * channel remains open.
- *
- *  @since 1.7
- */
-
-public interface AsynchronousChannel
-    extends Channel
-{
-    /**
-     * Closes this channel.
-     *
-     * <p> Any outstanding asynchronous operations upon this channel will
-     * complete with the exception {@link AsynchronousCloseException}. After a
-     * channel is closed then further attempts to initiate asynchronous I/O
-     * operations complete immediately with cause {@link ClosedChannelException}.
-     *
-     * <p>  This method otherwise behaves exactly as specified by the {@link
-     * Channel} interface.
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-
-    void close() throws IOException;
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannelGroup.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,317 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.io.IOException;
-import java.util.concurrent.*;
-
-import java.nio.channels.spi.AsynchronousChannelProvider;
-
-/**
- * A grouping of asynchronous channels for the purpose of resource sharing.
- *
- * <p> An asynchronous channel group encapsulates the mechanics required to
- * handle the completion of I/O operations initiated by {@link AsynchronousChannel
- * asynchronous channels} that are bound to the group. A group has an associated
- * thread pool to which tasks are submitted to handle I/O events and dispatch to
- * {@link CompletionHandler completion-handlers} that consume the result of
- * asynchronous operations performed on channels in the group. In addition to
- * handling I/O events, the pooled threads may also execute other tasks required
- * to support the execution of asynchronous I/O operations.
- *
- * <p> An asynchronous channel group is created by invoking the {@link
- * #withFixedThreadPool withFixedThreadPool} or {@link #withCachedThreadPool
- * withCachedThreadPool} methods with the appropriate thread pool. Channels are
- * bound to a group by specifying the group when constructing the channel. The
- * group <em>takes ownership</em> of the thread pool; termination of the group
- * results in the shutdown of the thread pool.
- *
- * <p> In addition to groups created explicitly, the Java virtual machine
- * maintains a system-wide <em>default group</em> that is constructed
- * automatically. Asynchronous channels that do not specify a group at
- * construction time are bound to the default group. The default group has an
- * associated thread pool that creates new threads as needed. The default group
- * may be configured by means of system properties defined in the table below.
- * Where the {@link java.util.concurrent.ThreadFactory ThreadFactory} for the
- * default group is not configured then the pooled threads of the default group
- * are {@link Thread#isDaemon daemon} threads.
- *
- * <table border>
- *   <tr>
- *     <th>System property</th>
- *     <th>Description</th>
- *   </tr>
- *   <tr>
- *   <tr>
- *     <td> {@code java.nio.channels.DefaultThreadPool.threadFactory} </td>
- *     <td> The value of this property is taken to be the fully-qualified name
- *     of a concrete {@link java.util.concurrent.ThreadFactory ThreadFactory}
- *     class. The class is loaded using the system class loader and instantiated.
- *     The factory's {@link java.util.concurrent.ThreadFactory#newThread
- *     newThread} method is invoked to create each thread for the default
- *     group's thread pool. If the process to load and instantiate the value
- *     of the property fails then an unspecified error is thrown during the
- *     construction of the default group. </td>
- *   </tr>
- *   <tr>
- *     <td> {@code java.nio.channels.DefaultThreadPool.initialSize} </td>
- *     <td> The value of the {@code initialSize} parameter for the default
- *     group (see {@link #withCachedThreadPool withCachedThreadPool}).
- *     The value of the property is taken to be the {@code String}
- *     representation of an {@code Integer} that is the initial size parameter.
- *     If the value cannot be parsed as an {@code Integer} it causes an
- *     unspecified error to be thrown during the construction of the default
- *     group. </td>
- *   </tr>
- * </table>
- *
- * <a name="threading"><h4>Threading</h4></a>
- *
- * <p> The completion handler for an I/O operation initiated on a channel bound
- * to a group is guaranteed to be invoked by one of the pooled threads in the
- * group. This ensures that the completion handler is run by a thread with the
- * expected <em>identity</em>.
- *
- * <p> Where an I/O operation completes immediately, and the initiating thread
- * is one of the pooled threads in the group then the completion handler may
- * be invoked directly by the initiating thread. To avoid stack overflow, an
- * implementation may impose a limit as to the number of activations on the
- * thread stack. Some I/O operations may prohibit invoking the completion
- * handler directly by the initiating thread (see {@link
- * AsynchronousServerSocketChannel#accept(Object,CompletionHandler) accept}).
- *
- * <a name="shutdown"><h4>Shutdown and Termination</h4></a>
- *
- * <p> The {@link #shutdown() shutdown} method is used to initiate an <em>orderly
- * shutdown</em> of the group. An orderly shutdown marks the group as shutdown;
- * further attempts to construct a channel that binds to the group will throw
- * {@link ShutdownChannelGroupException}. Whether or not a group is shutdown can
- * be tested using the {@link #isShutdown() isShutdown} method. Once shutdown, a
- * group <em>terminates</em> when all asynchronous channels that are bound to the
- * group are closed, all actively executing completion handlers have run to
- * completion, and resources used by the group are released. No attempt is made
- * to stop or interrupt threads that are executing completion handlers. The
- * {@link #isTerminated() isTerminated} method is used to test if the group has
- * terminated, and the {@link #awaitTermination awaitTermination} method can be
- * used to block until the group has terminated.
- *
- * <p> The {@link #shutdownNow() shutdownNow} method can be used to initiate a
- * <em>forceful shutdown</em> of the group. In addition to the actions performed
- * by an orderly shutdown, the {@code shutdownNow} method closes all open channels
- * in the group as if by invoking the {@link AsynchronousChannel#close close}
- * method.
- *
- * @since 1.7
- *
- * @see AsynchronousSocketChannel#open
- * @see AsynchronousServerSocketChannel#open
- */
-
-public abstract class AsynchronousChannelGroup {
-    private final AsynchronousChannelProvider provider;
-
-    /**
-     * Initialize a new instance of this class.
-     *
-     * @param   provider
-     *          The asynchronous channel provider for this group
-     */
-    protected AsynchronousChannelGroup(AsynchronousChannelProvider provider) {
-        this.provider = provider;
-    }
-
-    /**
-     * Returns the provider that created this channel group.
-     *
-     * @return  The provider that created this channel group
-     */
-    public final AsynchronousChannelProvider provider() {
-        return provider;
-    }
-
-    /**
-     * Creates an asynchronous channel group with a fixed thread pool.
-     *
-     * <p> The {@code executor} parameter is an {@code ExecutorService} that
-     * reuses a fixed number of threads operating off a shared unbounded queue.
-     * At any point, at most {@code nThreads} threads will be active processing
-     * tasks that are submitted to handle I/O events and dispatch completion
-     * results for operations initiated on asynchronous channels in the group.
-     *
-     * <p> The executor is intended to be used for the exclusive use of the
-     * resulting asynchronous channel group. Adjusting the maximum allowed
-     * number of threads or other policy parameters after the channel group is
-     * created is not recommended. Termination of the group results in the orderly
-     * {@link ExecutorService#shutdown shutdown} of the executor service.
-     * Shutting down the executor service by other means results in unspecified
-     * behavior.
-     *
-     * <p> The group is created by invoking the {@link
-     * AsynchronousChannelProvider#openAsynchronousChannelGroup
-     * openAsynchronousChannelGroup} method of the system-wide default {@link
-     * AsynchronousChannelProvider} object.
-     *
-     * @param   executor
-     *          The thread pool for the resulting group
-     * @param   nThreads
-     *          The number of threads in the pool
-     *
-     * @return  A new asynchronous channel group
-     *
-     * @throws  IllegalArgumentException
-     *          If {@code nThreads <= 0}
-     * @throws  IOException
-     *          If an I/O error occurs
-     *
-     * @see Executors#newFixedThreadPool
-     */
-    public static AsynchronousChannelGroup withFixedThreadPool(ExecutorService executor,
-                                                               int nThreads)
-        throws IOException
-    {
-        return AsynchronousChannelProvider.provider()
-            .openAsynchronousChannelGroup(AsynchronousChannelProvider.ThreadPoolType.FIXED,
-                                          executor,
-                                          nThreads);
-    }
-
-    /**
-     * Creates an asynchronous channel group that creates new threads as needed.
-     *
-     * <p> The {@code executor} parameter is an {@code ExecutorService} that
-     * creates new threads as needed to execute tasks that are submitted to
-     * handle I/O events and dispatch completion results for operations initiated
-     * on asynchronous channels in the group. It may reuse previously constructed
-     * threads when they are available.
-     *
-     * <p> The {@code initialSize} parameter may be used by the implementation
-     * as a <em>hint</em> as to the initial number of tasks it may submit. For
-     * example, it may be used to indictae the initial number of threads that
-     * wait on I/O events.
-     *
-     * <p> The executor is intended to be used for the exclusive use of the
-     * resulting asynchronous channel group. Termination of the group results in
-     * the orderly  {@link ExecutorService#shutdown shutdown} of the executor
-     * service. Shutting down the executor service by other means results in
-     * unspecified behavior.
-     *
-     * <p> The group is created by invoking the {@link
-     * AsynchronousChannelProvider#openAsynchronousChannelGroup
-     * openAsynchronousChannelGroup} method of the system-wide default {@link
-     * AsynchronousChannelProvider} object.
-     *
-     * @param   executor
-     *          The thread pool for the resulting group
-     * @param   initialSize
-     *          A value {@code >=0} or a negative value for implementation
-     *          specific default
-     *
-     * @return  A new asynchronous channel group
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     *
-     * @see Executors#newCachedThreadPool
-     */
-    public static AsynchronousChannelGroup withCachedThreadPool(ExecutorService executor,
-                                                                int initialSize)
-        throws IOException
-    {
-        return AsynchronousChannelProvider.provider()
-            .openAsynchronousChannelGroup(AsynchronousChannelProvider.ThreadPoolType.CACHED,
-                                          executor,
-                                          initialSize);
-    }
-
-    /**
-     * Tells whether or not this asynchronous channel group is shutdown.
-     *
-     * @return  {@code true} if this asynchronous channel group is shutdown or
-     *          has been marked for shutdown.
-     */
-    public abstract boolean isShutdown();
-
-    /**
-     * Tells whether or not this group has terminated.
-     *
-     * <p> Where this method returns {@code true}, then the associated has
-     * also {@link ExecutorService#isTerminated terminated}.
-     *
-     * @return  {@code true} if this group has terminated
-     */
-    public abstract boolean isTerminated();
-
-    /**
-     * Initiates an orderly shutdown of the group.
-     *
-     * <p> This method marks the group as shutdown. Further attempts to construct
-     * channel that binds to this group will throw {@link ShutdownChannelGroupException}.
-     * The group terminates when all asynchronous channels in the group are
-     * closed, all actively executing completion handlers have run to completion,
-     * and all resources have been released. This method has no effect if the
-     * group is already shutdown.
-     */
-    public abstract void shutdown();
-
-    /**
-     * Shuts down the group and closes all open channels in the group.
-     *
-     * <p> In addition to the actions performed by the {@link #shutdown() shutdown}
-     * method, this method invokes the {@link AsynchronousChannel#close close}
-     * method on all open channels in the group. This method does not attempt to
-     * stop or interrupt threads that are executing completion handlers. The
-     * group terminates when all actively executing completion handlers have run
-     * to completion and all resources have been released. This method may be
-     * invoked at any time. If some other thread has already invoked it, then
-     * another invocation will block until the first invocation is complete,
-     * after which it will return without effect.
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public abstract void shutdownNow() throws IOException;
-
-    /**
-     * Awaits termination of the group.
-
-     * <p> This method blocks until the group has terminated, or the timeout
-     * occurs, or the current thread is interrupted, whichever happens first.
-     *
-     * @param   timeout
-     *          The maximum time to wait, or zero or less to not wait
-     * @param   unit
-     *          The time unit of the timeout argument
-     *
-     * @return  {@code true} if the group has terminated; {@code false} if the
-     *          timeout elapsed before termination
-     *
-     * @throws  InterruptedException
-     *          If interrupted while waiting
-     */
-    public abstract boolean awaitTermination(long timeout, TimeUnit unit)
-        throws InterruptedException;
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousDatagramChannel.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,707 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.Future;
-import java.io.IOException;
-import java.net.SocketAddress;
-import java.nio.ByteBuffer;
-
-import java.net.ProtocolFamily;
-import java.net.SocketOption;
-
-import java.nio.channels.spi.AsynchronousChannelProvider;
-
-/**
- * An asynchronous channel for datagram-oriented sockets.
- *
- * <p> An asynchronous datagram channel is created by invoking one of the {@link
- * #open open} methods defined by this class. It is not possible to create a channel
- * for an arbitrary, pre-existing datagram socket. A newly-created asynchronous
- * datagram channel is open but not connected. It need not be connected in order
- * for the {@link #send send} and {@link #receive receive} methods to be used.
- * A datagram channel may be connected, by invoking its {@link #connect connect}
- * method, in order to avoid the overhead of the security checks that are otherwise
- * performed as part of every send and receive operation when a security manager
- * is set. The channel must be connected in order to use the {@link #read read}
- * and {@link #write write} methods, since those methods do not accept or return
- * socket addresses. Once connected, an asynchronous datagram channel remains
- * connected until it is disconnected or closed.
- *
- * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
- * setOption} method. An asynchronous datagram channel to an Internet Protocol
- * (IP) socket supports the following options:
- * <blockquote>
- * <table border>
- *   <tr>
- *     <th>Option Name</th>
- *     <th>Description</th>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_SNDBUF SO_SNDBUF} </td>
- *     <td> The size of the socket send buffer </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_RCVBUF SO_RCVBUF} </td>
- *     <td> The size of the socket receive buffer </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_REUSEADDR SO_REUSEADDR} </td>
- *     <td> Re-use address </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_BROADCAST SO_BROADCAST} </td>
- *     <td> Allow transmission of broadcast datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_TOS IP_TOS} </td>
- *     <td> The Type of Service (ToS) octet in the Internet Protocol (IP) header </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_IF IP_MULTICAST_IF} </td>
- *     <td> The network interface for Internet Protocol (IP) multicast datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_TTL
- *       IP_MULTICAST_TTL} </td>
- *     <td> The <em>time-to-live</em> for Internet Protocol (IP) multicast
- *       datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_LOOP
- *       IP_MULTICAST_LOOP} </td>
- *     <td> Loopback for Internet Protocol (IP) multicast datagrams </td>
- *   </tr>
- * </table>
- * </blockquote>
- * Additional (implementation specific) options may also be supported.
- *
- * <p> <b>Usage Example:</b>
- * <pre>
- *  final AsynchronousDatagramChannel dc = AsynchronousDatagramChannel.open()
- *      .bind(new InetSocketAddress(4000));
- *
- *  // print the source address of all packets that we receive
- *  dc.receive(buffer, buffer, new CompletionHandler&lt;SocketAddress,ByteBuffer&gt;() {
- *      public void completed(SocketAddress sa, ByteBuffer buffer) {
- *          try {
- *               System.out.println(sa);
- *
- *               buffer.clear();
- *               dc.receive(buffer, buffer, this);
- *           } catch (...) { ... }
- *      }
- *      public void failed(Throwable exc, ByteBuffer buffer) {
- *          ...
- *      }
- *      public void cancelled(ByteBuffer buffer) {
- *          ...
- *      }
- *  });
- * </pre>
- *
- * @since 1.7
- */
-
-public abstract class AsynchronousDatagramChannel
-    implements AsynchronousByteChannel, MulticastChannel
-{
-    private final AsynchronousChannelProvider provider;
-
-    /**
-     * Initializes a new instance of this class.
-     */
-    protected AsynchronousDatagramChannel(AsynchronousChannelProvider provider) {
-        this.provider = provider;
-    }
-
-    /**
-     * Returns the provider that created this channel.
-     */
-    public final AsynchronousChannelProvider provider() {
-        return provider;
-    }
-
-    /**
-     * Opens an asynchronous datagram channel.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * java.nio.channels.spi.AsynchronousChannelProvider#openAsynchronousDatagramChannel
-     * openAsynchronousDatagramChannel} method on the {@link
-     * java.nio.channels.spi.AsynchronousChannelProvider} object that created
-     * the given group. If the group parameter is <tt>null</tt> then the
-     * resulting channel is created by the system-wide default provider, and
-     * bound to the <em>default group</em>.
-     *
-     * <p> The <tt>family</tt> parameter is used to specify the {@link ProtocolFamily}.
-     * If the datagram channel is to be used for Internet Protocol {@link
-     * MulticastChannel multicasting} then this parameter should correspond to
-     * the address type of the multicast groups that this channel will join.
-     *
-     * @param   family
-     *          The protocol family, or <tt>null</tt> to use the default protocol
-     *          family
-     * @param   group
-     *          The group to which the newly constructed channel should be bound,
-     *          or <tt>null</tt> for the default group
-     *
-     * @return  A new asynchronous datagram channel
-     *
-     * @throws  UnsupportedOperationException
-     *          If the specified protocol family is not supported. For example,
-     *          suppose the parameter is specified as {@link
-     *          java.net.StandardProtocolFamily#INET6 INET6} but IPv6 is not
-     *          enabled on the platform.
-     * @throws  ShutdownChannelGroupException
-     *          The specified group is shutdown
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public static AsynchronousDatagramChannel open(ProtocolFamily family,
-                                                   AsynchronousChannelGroup group)
-        throws IOException
-    {
-        AsynchronousChannelProvider provider = (group == null) ?
-            AsynchronousChannelProvider.provider() : group.provider();
-        return provider.openAsynchronousDatagramChannel(family, group);
-    }
-
-    /**
-     * Opens an asynchronous datagram channel.
-     *
-     * <p> This method returns an asynchronous datagram channel that is
-     * bound to the <em>default group</em>. This method is equivalent to evaluating
-     * the expression:
-     * <blockquote><pre>
-     * open((ProtocolFamily)null,&nbsp;(AsynchronousChannelGroup)null);
-     * </pre></blockquote>
-     *
-     * @return  A new asynchronous datagram channel
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public static AsynchronousDatagramChannel open()
-        throws IOException
-    {
-        return open(null, null);
-    }
-
-    // -- Socket-specific operations --
-
-    /**
-     * @throws  AlreadyBoundException               {@inheritDoc}
-     * @throws  UnsupportedAddressTypeException     {@inheritDoc}
-     * @throws  ClosedChannelException              {@inheritDoc}
-     * @throws  IOException                         {@inheritDoc}
-     * @throws  SecurityException
-     *          If a security manager has been installed and its {@link
-     *          SecurityManager#checkListen checkListen} method denies the
-     *          operation
-     */
-
-    public abstract AsynchronousDatagramChannel bind(SocketAddress local)
-        throws IOException;
-
-    /**
-     * @throws  IllegalArgumentException                {@inheritDoc}
-     * @throws  ClosedChannelException                  {@inheritDoc}
-     * @throws  IOException                             {@inheritDoc}
-     */
-
-    public abstract <T> AsynchronousDatagramChannel setOption(SocketOption<T> name, T value)
-        throws IOException;
-
-    /**
-     * Returns the remote address to which this channel is connected.
-     *
-     * <p> Where the channel is connected to an Internet Protocol socket address
-     * then the return value from this method is of type {@link
-     * java.net.InetSocketAddress}.
-     *
-     * @return  The remote address; {@code null} if the channel's socket is not
-     *          connected
-     *
-     * @throws  ClosedChannelException
-     *          If the channel is closed
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public abstract SocketAddress getRemoteAddress() throws IOException;
-
-    /**
-     * Connects this channel's socket.
-     *
-     * <p> The channel's socket is configured so that it only receives
-     * datagrams from, and sends datagrams to, the given remote <i>peer</i>
-     * address.  Once connected, datagrams may not be received from or sent to
-     * any other address.  A datagram socket remains connected until it is
-     * explicitly disconnected or until it is closed.
-     *
-     * <p> This method performs exactly the same security checks as the {@link
-     * java.net.DatagramSocket#connect connect} method of the {@link
-     * java.net.DatagramSocket} class.  That is, if a security manager has been
-     * installed then this method verifies that its {@link
-     * java.lang.SecurityManager#checkAccept checkAccept} and {@link
-     * java.lang.SecurityManager#checkConnect checkConnect} methods permit
-     * datagrams to be received from and sent to, respectively, the given
-     * remote address.
-     *
-     * <p> This method may be invoked at any time. Whether it has any effect
-     * on outstanding read or write operations is implementation specific and
-     * therefore not specified.
-     *
-     * @param  remote
-     *         The remote address to which this channel is to be connected
-     *
-     * @return  This datagram channel
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     *
-     * @throws  SecurityException
-     *          If a security manager has been installed
-     *          and it does not permit access to the given remote address
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract AsynchronousDatagramChannel connect(SocketAddress remote)
-        throws IOException;
-
-    /**
-     * Disconnects this channel's socket.
-     *
-     * <p> The channel's socket is configured so that it can receive datagrams
-     * from, and sends datagrams to, any remote address so long as the security
-     * manager, if installed, permits it.
-     *
-     * <p> This method may be invoked at any time.  It will not have any effect
-     * on read or write operations that are already in progress at the moment
-     * that it is invoked.
-     *
-     * <p> This method may be invoked at any time. Whether it has any effect
-     * on outstanding read or write operations is implementation specific and
-     * therefore not specified.
-     *
-     * @return  This datagram channel
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract AsynchronousDatagramChannel disconnect() throws IOException;
-
-    /**
-     * Receives a datagram via this channel.
-     *
-     * <p> This method initiates the receiving of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The <tt>Future</tt>'s {@link Future#get() get} method returns
-     * the source address of the datagram upon successful completion.
-     *
-     * <p> The datagram is transferred into the given byte buffer starting at
-     * its current position, as if by a regular {@link AsynchronousByteChannel#read
-     * read} operation. If there are fewer bytes remaining in the buffer
-     * than are required to hold the datagram then the remainder of the datagram
-     * is silently discarded.
-     *
-     * <p> If a timeout is specified and the timeout elapses before the operation
-     * completes then the operation completes with the exception {@link
-     * InterruptedByTimeoutException}.
-     *
-     * <p> When a security manager has been installed and the channel is not
-     * connected, then it verifies that the source's address and port number are
-     * permitted by the security manager's {@link SecurityManager#checkAccept
-     * checkAccept} method. The permission check is performed with privileges that
-     * are restricted by the calling context of this method. If the permission
-     * check fails then the operation completes with a {@link SecurityException}.
-     * The overhead of this security check can be avoided by first connecting the
-     * socket via the {@link #connect connect} method.
-     *
-     * @param   dst
-     *          The buffer into which the datagram is to be transferred
-     * @param   timeout
-     *          The timeout, or <tt>0L</tt> for no timeout
-     * @param   unit
-     *          The time unit of the <tt>timeout</tt> argument
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the timeout is negative or the buffer is read-only
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public abstract <A> Future<SocketAddress> receive(ByteBuffer dst,
-                                                      long timeout,
-                                                      TimeUnit unit,
-                                                      A attachment,
-                                                      CompletionHandler<SocketAddress,? super A> handler);
-
-    /**
-     * Receives a datagram via this channel.
-     *
-     * <p> This method initiates the receiving of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The <tt>Future</tt>'s {@link Future#get() get} method returns
-     * the source address of the datagram upon successful completion.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #receive(ByteBuffer,long,TimeUnit,Object,CompletionHandler)} with a
-     * timeout of <tt>0L</tt>.
-     *
-     * @param   dst
-     *          The buffer into which the datagram is to be transferred
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the buffer is read-only
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public final <A> Future<SocketAddress> receive(ByteBuffer dst,
-                                                   A attachment,
-                                                   CompletionHandler<SocketAddress,? super A> handler)
-    {
-        return receive(dst, 0L, TimeUnit.MILLISECONDS, attachment, handler);
-    }
-
-    /**
-     * Receives a datagram via this channel.
-     *
-     * <p> This method initiates the receiving of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The <tt>Future</tt>'s {@link Future#get() get} method returns
-     * the source address of the datagram upon successful completion.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #receive(ByteBuffer,long,TimeUnit,Object,CompletionHandler)} with a
-     * timeout of {@code 0L}, and an attachment and completion handler
-     * of {@code null}.
-     *
-     * @param   dst
-     *          The buffer into which the datagram is to be transferred
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the buffer is read-only
-     */
-    public final <A> Future<SocketAddress> receive(ByteBuffer dst) {
-        return receive(dst, 0L, TimeUnit.MILLISECONDS, null, null);
-    }
-
-    /**
-     * Sends a datagram via this channel.
-     *
-     * <p> This method initiates sending of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The operation sends the remaining bytes in the given buffer as a single
-     * datagram to the given target address. The result of the operation, obtained
-     * by invoking the <tt>Future</tt>'s {@link Future#get() get}
-     * method, is the number of bytes sent.
-     *
-     * <p> The datagram is transferred from the byte buffer as if by a regular
-     * {@link AsynchronousByteChannel#write write} operation.
-     *
-     * <p> If a timeout is specified and the timeout elapses before the operation
-     * completes then the operation completes with the exception {@link
-     * InterruptedByTimeoutException}.
-     *
-     * <p> If there is a security manager installed and the the channel is not
-     * connected then this method verifies that the target address and port number
-     * are permitted by the security manager's {@link SecurityManager#checkConnect
-     * checkConnect} method.  The overhead of this security check can be avoided
-     * by first connecting the socket via the {@link #connect connect} method.
-     *
-     * @param   src
-     *          The buffer containing the datagram to be sent
-     * @param   target
-     *          The address to which the datagram is to be sent
-     * @param   timeout
-     *          The timeout, or <tt>0L</tt> for no timeout
-     * @param   unit
-     *          The time unit of the <tt>timeout</tt> argument
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  UnresolvedAddressException
-     *          If the given remote address is not fully resolved
-     * @throws  UnsupportedAddressTypeException
-     *          If the type of the given remote address is not supported
-     * @throws  IllegalArgumentException
-     *          If the channel's socket is connected and is connected to an
-     *          address that is not equal to {@code target}
-     * @throws  SecurityException
-     *          If a security manager has been installed and it does not permit
-     *          datagrams to be sent to the given address
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public abstract <A> Future<Integer> send(ByteBuffer src,
-                                             SocketAddress target,
-                                             long timeout,
-                                             TimeUnit unit,
-                                             A attachment,
-                                             CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * Sends a datagram via this channel.
-     *
-     * <p> This method initiates sending of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The operation sends the remaining bytes in the given buffer as a single
-     * datagram to the given target address. The result of the operation, obtained
-     * by invoking the <tt>Future</tt>'s {@link Future#get() get}
-     * method, is the number of bytes sent.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #send(ByteBuffer,SocketAddress,long,TimeUnit,Object,CompletionHandler)}
-     * with a timeout of <tt>0L</tt>.
-     *
-     * @param   src
-     *          The buffer containing the datagram to be sent
-     * @param   target
-     *          The address to which the datagram is to be sent
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  UnresolvedAddressException
-     *          If the given remote address is not fully resolved
-     * @throws  UnsupportedAddressTypeException
-     *          If the type of the given remote address is not supported
-     * @throws  IllegalArgumentException
-     *          If the channel's socket is connected and is connected to an
-     *          address that is not equal to {@code target}
-     * @throws  SecurityException
-     *          If a security manager has been installed and it does not permit
-     *          datagrams to be sent to the given address
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public final <A> Future<Integer> send(ByteBuffer src,
-                                          SocketAddress target,
-                                          A attachment,
-                                          CompletionHandler<Integer,? super A> handler)
-    {
-        return send(src, target, 0L, TimeUnit.MILLISECONDS, attachment, handler);
-    }
-
-    /**
-     * Sends a datagram via this channel.
-     *
-     * <p> This method initiates sending of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The operation sends the remaining bytes in the given buffer as a single
-     * datagram to the given target address. The result of the operation, obtained
-     * by invoking the <tt>Future</tt>'s {@link Future#get() get}
-     * method, is the number of bytes sent.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #send(ByteBuffer,SocketAddress,long,TimeUnit,Object,CompletionHandler)}
-     * with a timeout of {@code 0L} and an attachment and completion handler
-     * of {@code null}.
-     *
-     * @param   src
-     *          The buffer containing the datagram to be sent
-     * @param   target
-     *          The address to which the datagram is to be sent
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  UnresolvedAddressException
-     *          If the given remote address is not fully resolved
-     * @throws  UnsupportedAddressTypeException
-     *          If the type of the given remote address is not supported
-     * @throws  IllegalArgumentException
-     *          If the channel's socket is connected and is connected to an
-     *          address that is not equal to {@code target}
-     * @throws  SecurityException
-     *          If a security manager has been installed and it does not permit
-     *          datagrams to be sent to the given address
-     */
-    public final Future<Integer> send(ByteBuffer src, SocketAddress target) {
-        return send(src, target, 0L, TimeUnit.MILLISECONDS, null, null);
-    }
-
-    /**
-     * Receives a datagram via this channel.
-     *
-     * <p> This method initiates the receiving of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The <tt>Future</tt>'s {@link Future#get() get} method returns
-     * the number of bytes transferred upon successful completion.
-     *
-     * <p> This method may only be invoked if this channel is connected, and it
-     * only accepts datagrams from the peer that the channel is connected too.
-     * The datagram is transferred into the given byte buffer starting at
-     * its current position and exactly as specified in the {@link
-     * AsynchronousByteChannel} interface. If there are fewer bytes
-     * remaining in the buffer than are required to hold the datagram then the
-     * remainder of the datagram is silently discarded.
-     *
-     * <p> If a timeout is specified and the timeout elapses before the operation
-     * completes then the operation completes with the exception {@link
-     * InterruptedByTimeoutException}.
-     *
-     * @param   dst
-     *          The buffer into which the datagram is to be transferred
-     * @param   timeout
-     *          The timeout, or <tt>0L</tt> for no timeout
-     * @param   unit
-     *          The time unit of the <tt>timeout</tt> argument
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the timeout is negative or buffer is read-only
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public abstract <A> Future<Integer> read(ByteBuffer dst,
-                                             long timeout,
-                                             TimeUnit unit,
-                                             A attachment,
-                                             CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-
-    public final <A> Future<Integer> read(ByteBuffer dst,
-                                          A attachment,
-                                          CompletionHandler<Integer,? super A> handler)
-    {
-        return read(dst, 0L, TimeUnit.MILLISECONDS, attachment, handler);
-    }
-
-    /**
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     */
-
-    public final Future<Integer> read(ByteBuffer dst) {
-        return read(dst, 0L, TimeUnit.MILLISECONDS, null, null);
-    }
-
-    /**
-     * Writes a datagram to this channel.
-     *
-     * <p> This method initiates sending of a datagram, returning a
-     * <tt>Future</tt> representing the pending result of the operation.
-     * The operation sends the remaining bytes in the given buffer as a single
-     * datagram. The result of the operation, obtained by invoking the
-     * <tt>Future</tt>'s {@link Future#get() get} method, is the
-     * number of bytes sent.
-     *
-     * <p> The datagram is transferred from the byte buffer as if by a regular
-     * {@link AsynchronousByteChannel#write write} operation.
-     *
-     * <p> This method may only be invoked if this channel is connected,
-     * in which case it sends datagrams directly to the socket's peer.  Otherwise
-     * it behaves exactly as specified in the {@link
-     * AsynchronousByteChannel} interface.
-     *
-     * <p> If a timeout is specified and the timeout elapses before the operation
-     * completes then the operation completes with the exception {@link
-     * InterruptedByTimeoutException}.
-     *
-     * @param   src
-     *          The buffer containing the datagram to be sent
-     * @param   timeout
-     *          The timeout, or <tt>0L</tt> for no timeout
-     * @param   unit
-     *          The time unit of the <tt>timeout</tt> argument
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a <tt>Future</tt> object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the timeout is negative
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public abstract <A> Future<Integer> write(ByteBuffer src,
-                                              long timeout,
-                                              TimeUnit unit,
-                                              A attachment,
-                                              CompletionHandler<Integer,? super A> handler);
-    /**
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-
-    public final <A> Future<Integer> write(ByteBuffer src,
-                                           A attachment,
-                                           CompletionHandler<Integer,? super A> handler)
-    {
-        return write(src, 0L, TimeUnit.MILLISECONDS, attachment, handler);
-    }
-
-    /**
-     * @throws  NotYetConnectedException
-     *          If this channel is not connected
-     */
-
-    public final Future<Integer> write(ByteBuffer src) {
-        return write(src, 0L, TimeUnit.MILLISECONDS, null, null);
-    }
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousFileChannel.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,777 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.nio.ByteBuffer;
-import java.io.IOException;
-import java.util.concurrent.Future;
-import java.util.concurrent.ExecutorService;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Collections;
-
-import java.nio.file.OpenOption;
-import java.nio.file.Path;
-import java.nio.file.attribute.FileAttribute;
-import java.nio.file.spi.FileSystemProvider;
-
-/**
- * An asynchronous channel for reading, writing, and manipulating a file.
- *
- * <p> An asynchronous file channel is created when a file is opened by invoking
- * one of the {@link #open open} methods defined by this class. The file contains
- * a variable-length sequence of bytes that can be read and written and whose
- * current size can be {@link #size() queried}. The size of the file increases
- * when bytes are written beyond its  current size; the size of the file decreases
- * when it is {@link #truncate truncated}.
- *
- * <p> An asynchronous file channel does not have a <i>current position</i>
- * within the file. Instead, the file position is specified to each read and
- * write operation.
- *
- * <p> In addition to read and write operations, this class defines the
- * following operations: </p>
- *
- * <ul>
- *
- *   <li><p> Updates made to a file may be {@link #force <i>forced
- *   out</i>} to the underlying storage device, ensuring that data are not
- *   lost in the event of a system crash.  </p></li>
- *
- *   <li><p> A region of a file may be {@link FileLock <i>locked</i>}
- *   against access by other programs.  </p></li>
- *
- * </ul>
- *
- * <p> The {@link #read read}, {@link #write write}, and {@link #lock lock}
- * methods defined by this class are asynchronous  and return a {@link Future}
- * to represent the pending result of the operation. This may be used to check
- * if the operation has completed, to wait for its completion, and to retrieve
- * the result. These method may optionally specify a {@link CompletionHandler}
- * that is invoked to consume the result of the I/O operation when it completes.
- *
- * <p> An {@code AsynchronousFileChannel} is associated with a thread pool to
- * which tasks are submitted to handle I/O events and dispatch to completion
- * handlers that consume the results of I/O operations on the channel. The
- * completion handler for an I/O operation initiated on a channel is guaranteed
- * to be invoked by one threads in the thread pool (This ensures that the
- * completion handler is run by a thread with the expected <em>identity</em>).
- * Where an I/O operation completes immediately, and the initiating thread is
- * itself a thread in the thread pool, then the completion handler may be invoked
- * directly by the initiating thread. When an {@code AsynchronousFileChannel} is
- * created without specifying a thread pool then the channel is associated with
- * a system-dependent and default thread pool that may be shared with other
- * channels. The default thread pool is configured by the system properties
- * defined by the {@link AsynchronousChannelGroup} class.
- *
- * <p> Channels of this type are safe for use by multiple concurrent threads. The
- * {@link Channel#close close} method may be invoked at any time, as specified
- * by the {@link Channel} interface. This causes all outstanding asynchronous
- * operations on the channel to complete with the exception {@link
- * AsynchronousCloseException}. Multiple read and write operations may be
- * outstanding at the same time. When multiple read and write operations are
- * outstanding then the ordering of the I/O operations, and the order that the
- * completion handlers are invoked, is not specified; they are not, in particular,
- * guaranteed to execute in the order that the operations were initiated. The
- * {@link java.nio.ByteBuffer ByteBuffers} used when reading or writing are not
- * safe for use by multiple concurrent I/O operations. Furthermore, after an I/O
- * operation is initiated then care should be taken to ensure that the buffer is
- * not accessed until after the operation has completed.
- *
- * <p> As with {@link FileChannel}, the view of a file provided by an instance of
- * this class is guaranteed to be consistent with other views of the same file
- * provided by other instances in the same program.  The view provided by an
- * instance of this class may or may not, however, be consistent with the views
- * seen by other concurrently-running programs due to caching performed by the
- * underlying operating system and delays induced by network-filesystem protocols.
- * This is true regardless of the language in which these other programs are
- * written, and whether they are running on the same machine or on some other
- * machine.  The exact nature of any such inconsistencies are system-dependent
- * and are therefore unspecified.
- *
- * @since 1.7
- */
-
-public abstract class AsynchronousFileChannel
-    implements AsynchronousChannel
-{
-    /**
-     * Initializes a new instance of this class.
-     */
-    protected AsynchronousFileChannel() {
-    }
-
-    /**
-     * Closes this channel.
-     *
-     * <p> If this channel is associated with its own thread pool then closing
-     * the channel causes the thread pool to shutdown after all actively
-     * executing completion handlers have completed. No attempt is made to stop
-     * or interrupt actively completion handlers.
-     *
-     * <p> This method otherwise behaves exactly as specified by the {@link
-     * AsynchronousChannel} interface.
-     *
-     * @throws  IOException     {@inheritDoc}
-     */
-
-    public abstract void close() throws IOException;
-
-    /**
-     * Opens or creates a file for reading and/or writing, returning an
-     * asynchronous file channel to access the file.
-     *
-     * <p> The {@code options} parameter determines how the file is opened.
-     * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE
-     * WRITE} options determines if the file should be opened for reading and/or
-     * writing. If neither option is contained in the array then an existing file
-     * is opened for  reading.
-     *
-     * <p> In addition to {@code READ} and {@code WRITE}, the following options
-     * may be present:
-     *
-     * <table border=1 cellpadding=5 summary="">
-     * <tr> <th>Option</th> <th>Description</th> </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>
-     *   <td> When opening an existing file, the file is first truncated to a
-     *   size of 0 bytes. This option is ignored when the file is opened only
-     *   for reading.</td>
-     * </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>
-     *   <td> If this option is present then a new file is created, failing if
-     *   the file already exists. When creating a file the check for the
-     *   existence of the file and the creation of the file if it does not exist
-     *   is atomic with respect to other file system operations. This option is
-     *   ignored when the file is opened only for reading. </td>
-     * </tr>
-     * <tr>
-     *   <td > {@link StandardOpenOption#CREATE CREATE} </td>
-     *   <td> If this option is present then an existing file is opened if it
-     *   exists, otherwise a new file is created. When creating a file the check
-     *   for the existence of the file and the creation of the file if it does
-     *   not exist is atomic with respect to other file system operations. This
-     *   option is ignored if the {@code CREATE_NEW} option is also present or
-     *   the file is opened only for reading. </td>
-     * </tr>
-     * <tr>
-     *   <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>
-     *   <td> When this option is present then the implementation makes a
-     *   <em>best effort</em> attempt to delete the file when closed by the
-     *   the {@link #close close} method. If the {@code close} method is not
-     *   invoked then a <em>best effort</em> attempt is made to delete the file
-     *   when the Java virtual machine terminates. </td>
-     * </tr>
-     * <tr>
-     *   <td>{@link StandardOpenOption#SPARSE SPARSE} </td>
-     *   <td> When creating a new file this option is a <em>hint</em> that the
-     *   new file will be sparse. This option is ignored when not creating
-     *   a new file. </td>
-     * </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#SYNC SYNC} </td>
-     *   <td> Requires that every update to the file's content or metadata be
-     *   written synchronously to the underlying storage device. (see <a
-     *   href="../file/package-summary.html#integrity"> Synchronized I/O file
-     *   integrity</a>). </td>
-     * <tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#DSYNC DSYNC} </td>
-     *   <td> Requires that every update to the file's content be written
-     *   synchronously to the underlying storage device. (see <a
-     *   href="../file/package-summary.html#integrity"> Synchronized I/O file
-     *   integrity</a>). </td>
-     * </tr>
-     * </table>
-     *
-     * <p> An implementation may also support additional options.
-     *
-     * <p> The {@code executor} parameter is the {@link ExecutorService} to
-     * which tasks are submitted to handle I/O events and dispatch completion
-     * results for operations initiated on resulting channel.
-     * The nature of these tasks is highly implementation specific and so care
-     * should be taken when configuring the {@code Executor}. Minimally it
-     * should support an unbounded work queue and should not run tasks on the
-     * caller thread of the {@link ExecutorService#execute execute} method.
-     * {@link #close Closing} the channel results in the orderly {@link
-     * ExecutorService#shutdown shutdown} of the executor service. Shutting down
-     * the executor service by other means results in unspecified behavior.
-     *
-     * <p> The {@code attrs} parameter is an optional array of file {@link
-     * FileAttribute file-attributes} to set atomically when creating the file.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * FileSystemProvider#newFileChannel newFileChannel} method on the
-     * provider that created the {@code Path}.
-     *
-     * @param   file
-     *          The path of the file to open or create
-     * @param   options
-     *          Options specifying how the file is opened
-     * @param   executor
-     *          The thread pool or {@code null} to associate the channel with
-     *          the default thread pool
-     * @param   attrs
-     *          An optional list of file attributes to set atomically when
-     *          creating the file
-     *
-     * @return  A new asynchronous file channel
-     *
-     * @throws  IllegalArgumentException
-     *          If the set contains an invalid combination of options
-     * @throws  UnsupportedOperationException
-     *          If the {@code file} is associated with a provider that does not
-     *          support creating asynchronous file channels, or an unsupported
-     *          open option is specified, or the array contains an attribute that
-     *          cannot be set atomically when creating the file
-     * @throws  IOException
-     *          If an I/O error occurs
-     * @throws  SecurityException
-     *          If a security manager is installed and it denies an
-     *          unspecified permission required by the implementation.
-     *          In the case of the default provider, the {@link
-     *          SecurityManager#checkRead(String)} method is invoked to check
-     *          read access if the file is opened for reading. The {@link
-     *          SecurityManager#checkWrite(String)} method is invoked to check
-     *          write access if the file is opened for writing
-     */
-    public static AsynchronousFileChannel open(Path file,
-                                               Set<? extends OpenOption> options,
-                                               ExecutorService executor,
-                                               FileAttribute<?>... attrs)
-        throws IOException
-    {
-        FileSystemProvider provider = file.getFileSystem().provider();
-        return provider.newAsynchronousFileChannel(file, options, executor, attrs);
-    }
-
-    private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0];
-
-    /**
-     * Opens or creates a file for reading and/or writing, returning an
-     * asynchronous file channel to access the file.
-     *
-     * <p> An invocation of this method behaves in exactly the same way as the
-     * invocation
-     * <pre>
-     *     ch.{@link #open(Path,Set,ExecutorService,FileAttribute[]) open}(file, opts, null, new FileAttribute&lt;?&gt;[0]);
-     * </pre>
-     * where {@code opts} is a {@code Set} containing the options specified to
-     * this method.
-     *
-     * <p> The resulting channel is associated with default thread pool to which
-     * tasks are submitted to handle I/O events and dispatch to completion
-     * handlers that consume the result of asynchronous operations performed on
-     * the resulting channel.
-     *
-     * @param   file
-     *          The path of the file to open or create
-     * @param   options
-     *          Options specifying how the file is opened
-     *
-     * @return  A new asynchronous file channel
-     *
-     * @throws  IllegalArgumentException
-     *          If the set contains an invalid combination of options
-     * @throws  UnsupportedOperationException
-     *          If the {@code file} is associated with a provider that does not
-     *          support creating file channels, or an unsupported open option is
-     *          specified
-     * @throws  IOException
-     *          If an I/O error occurs
-     * @throws  SecurityException
-     *          If a security manager is installed and it denies an
-     *          unspecified permission required by the implementation.
-     *          In the case of the default provider, the {@link
-     *          SecurityManager#checkRead(String)} method is invoked to check
-     *          read access if the file is opened for reading. The {@link
-     *          SecurityManager#checkWrite(String)} method is invoked to check
-     *          write access if the file is opened for writing
-     */
-    public static AsynchronousFileChannel open(Path file, OpenOption... options)
-        throws IOException
-    {
-        Set<OpenOption> set = new HashSet<OpenOption>(options.length);
-        Collections.addAll(set, options);
-        return open(file, set, null, NO_ATTRIBUTES);
-    }
-
-    /**
-     * Returns the current size of this channel's file.
-     *
-     * @return  The current size of this channel's file, measured in bytes
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract long size() throws IOException;
-
-    /**
-     * Truncates this channel's file to the given size.
-     *
-     * <p> If the given size is less than the file's current size then the file
-     * is truncated, discarding any bytes beyond the new end of the file.  If
-     * the given size is greater than or equal to the file's current size then
-     * the file is not modified. </p>
-     *
-     * @param  size
-     *         The new size, a non-negative byte count
-     *
-     * @return  This file channel
-     *
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     *
-     * @throws  IllegalArgumentException
-     *          If the new size is negative
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract AsynchronousFileChannel truncate(long size) throws IOException;
-
-    /**
-     * Forces any updates to this channel's file to be written to the storage
-     * device that contains it.
-     *
-     * <p> If this channel's file resides on a local storage device then when
-     * this method returns it is guaranteed that all changes made to the file
-     * since this channel was created, or since this method was last invoked,
-     * will have been written to that device.  This is useful for ensuring that
-     * critical information is not lost in the event of a system crash.
-     *
-     * <p> If the file does not reside on a local device then no such guarantee
-     * is made.
-     *
-     * <p> The {@code metaData} parameter can be used to limit the number of
-     * I/O operations that this method is required to perform.  Passing
-     * {@code false} for this parameter indicates that only updates to the
-     * file's content need be written to storage; passing {@code true}
-     * indicates that updates to both the file's content and metadata must be
-     * written, which generally requires at least one more I/O operation.
-     * Whether this parameter actually has any effect is dependent upon the
-     * underlying operating system and is therefore unspecified.
-     *
-     * <p> Invoking this method may cause an I/O operation to occur even if the
-     * channel was only opened for reading.  Some operating systems, for
-     * example, maintain a last-access time as part of a file's metadata, and
-     * this time is updated whenever the file is read.  Whether or not this is
-     * actually done is system-dependent and is therefore unspecified.
-     *
-     * <p> This method is only guaranteed to force changes that were made to
-     * this channel's file via the methods defined in this class.
-     *
-     * @param   metaData
-     *          If {@code true} then this method is required to force changes
-     *          to both the file's content and metadata to be written to
-     *          storage; otherwise, it need only force content changes to be
-     *          written
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract void force(boolean metaData) throws IOException;
-
-    /**
-     * Acquires a lock on the given region of this channel's file.
-     *
-     * <p> This method initiates an operation to acquire a lock on the given region
-     * of this channel's file. The method returns a {@code Future} representing
-     * the pending result of the operation. Its {@link Future#get() get}
-     * method returns the {@link FileLock} on successful completion.
-     *
-     * <p> The region specified by the {@code position} and {@code size}
-     * parameters need not be contained within, or even overlap, the actual
-     * underlying file.  Lock regions are fixed in size; if a locked region
-     * initially contains the end of the file and the file grows beyond the
-     * region then the new portion of the file will not be covered by the lock.
-     * If a file is expected to grow in size and a lock on the entire file is
-     * required then a region starting at zero, and no smaller than the
-     * expected maximum size of the file, should be locked.  The two-argument
-     * {@link #lock(Object,CompletionHandler)} method simply locks a region
-     * of size {@link Long#MAX_VALUE}. If a lock that overlaps the requested
-     * region is already held by this Java virtual machine, or this method has
-     * been invoked to lock an overlapping region and that operation has not
-     * completed, then this method throws {@link OverlappingFileLockException}.
-     *
-     * <p> Some operating systems do not support a mechanism to acquire a file
-     * lock in an asynchronous manner. Consequently an implementation may
-     * acquire the file lock in a background thread or from a task executed by
-     * a thread in the associated thread pool. If there are many lock operations
-     * outstanding then it may consume threads in the Java virtual machine for
-     * indefinite periods.
-     *
-     * <p> Some operating systems do not support shared locks, in which case a
-     * request for a shared lock is automatically converted into a request for
-     * an exclusive lock.  Whether the newly-acquired lock is shared or
-     * exclusive may be tested by invoking the resulting lock object's {@link
-     * FileLock#isShared() isShared} method.
-     *
-     * <p> File locks are held on behalf of the entire Java virtual machine.
-     * They are not suitable for controlling access to a file by multiple
-     * threads within the same virtual machine.
-     *
-     * @param   position
-     *          The position at which the locked region is to start; must be
-     *          non-negative
-     * @param   size
-     *          The size of the locked region; must be non-negative, and the sum
-     *          {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
-     * @param   shared
-     *          {@code true} to request a shared lock, in which case this
-     *          channel must be open for reading (and possibly writing);
-     *          {@code false} to request an exclusive lock, in which case this
-     *          channel must be open for writing (and possibly reading)
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a {@code Future} object representing the pending result
-     *
-     * @throws  OverlappingFileLockException
-     *          If a lock that overlaps the requested region is already held by
-     *          this Java virtual machine, or there is already a pending attempt
-     *          to lock an overlapping region
-     * @throws  IllegalArgumentException
-     *          If the preconditions on the parameters do not hold
-     * @throws  NonReadableChannelException
-     *          If {@code shared} is true this channel but was not opened for reading
-     * @throws  NonWritableChannelException
-     *          If {@code shared} is false but this channel was not opened for writing
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, the channel is closed, and the channel
-     *          was originally created with its own thread pool
-     */
-    public abstract <A> Future<FileLock> lock(long position,
-                                              long size,
-                                              boolean shared,
-                                              A attachment,
-                                              CompletionHandler<FileLock,? super A> handler);
-
-    /**
-     * Acquires an exclusive lock on this channel's file.
-     *
-     * <p> This method initiates an operation to acquire an exclusive lock on this
-     * channel's file. The method returns a {@code Future} representing
-     * the pending result of the operation. Its {@link Future#get() get}
-     * method returns the {@link FileLock} on successful completion.
-     *
-     * <p> An invocation of this method of the form {@code ch.lock(att,handler)}
-     * behaves in exactly the same way as the invocation
-     * <pre>
-     *     ch.{@link #lock(long,long,boolean,Object,CompletionHandler) lock}(0L, Long.MAX_VALUE, false, att, handler)
-     * </pre>
-     *
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  a {@code Future} object representing the pending result
-     *
-     * @throws  OverlappingFileLockException
-     *          If a lock is already held by this Java virtual machine, or there
-     *          is already a pending attempt to lock a region
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, the channel is closed, and the channel
-     *          was originally created with its own thread pool
-     */
-    public final <A> Future<FileLock> lock(A attachment,
-                                           CompletionHandler<FileLock,? super A> handler)
-    {
-        return lock(0L, Long.MAX_VALUE, false, attachment, handler);
-    }
-
-    /**
-     * Acquires an exclusive lock on this channel's file.
-     *
-     * <p> This method initiates an operation to acquire an exclusive lock on this
-     * channel's file. The method returns a {@code Future} representing the
-     * pending result of the operation. Its {@link Future#get() get} method
-     * returns the {@link FileLock} on successful completion.
-     *
-     * <p> An invocation of this method behaves in exactly the same way as the
-     * invocation
-     * <pre>
-     *     ch.{@link #lock(long,long,boolean,Object,CompletionHandler) lock}(0L, Long.MAX_VALUE, false, null, null)
-     * </pre>
-     *
-     * @return  A {@code Future} object representing the pending result
-     *
-     * @throws  OverlappingFileLockException
-     *          If a lock is already held by this Java virtual machine, or there
-     *          is already a pending attempt to lock a region
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     */
-    public final Future<FileLock> lock() {
-        return lock(0L, Long.MAX_VALUE, false, null, null);
-    }
-
-    /**
-     * Attempts to acquire a lock on the given region of this channel's file.
-     *
-     * <p> This method does not block. An invocation always returns immediately,
-     * either having acquired a lock on the requested region or having failed to
-     * do so.  If it fails to acquire a lock because an overlapping lock is held
-     * by another program then it returns {@code null}.  If it fails to acquire
-     * a lock for any other reason then an appropriate exception is thrown.
-     *
-     * @param  position
-     *         The position at which the locked region is to start; must be
-     *         non-negative
-     *
-     * @param  size
-     *         The size of the locked region; must be non-negative, and the sum
-     *         {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
-     *
-     * @param  shared
-     *         {@code true} to request a shared lock,
-     *         {@code false} to request an exclusive lock
-     *
-     * @return  A lock object representing the newly-acquired lock,
-     *          or {@code null} if the lock could not be acquired
-     *          because another program holds an overlapping lock
-     *
-     * @throws  IllegalArgumentException
-     *          If the preconditions on the parameters do not hold
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     * @throws  OverlappingFileLockException
-     *          If a lock that overlaps the requested region is already held by
-     *          this Java virtual machine, or if another thread is already
-     *          blocked in this method and is attempting to lock an overlapping
-     *          region of the same file
-     * @throws  NonReadableChannelException
-     *          If {@code shared} is true this channel but was not opened for reading
-     * @throws  NonWritableChannelException
-     *          If {@code shared} is false but this channel was not opened for writing
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     *
-     * @see     #lock(Object,CompletionHandler)
-     * @see     #lock(long,long,boolean,Object,CompletionHandler)
-     * @see     #tryLock()
-     */
-    public abstract FileLock tryLock(long position, long size, boolean shared)
-        throws IOException;
-
-    /**
-     * Attempts to acquire an exclusive lock on this channel's file.
-     *
-     * <p> An invocation of this method of the form {@code ch.tryLock()}
-     * behaves in exactly the same way as the invocation
-     *
-     * <pre>
-     *     ch.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false) </pre>
-     *
-     * @return  A lock object representing the newly-acquired lock,
-     *          or {@code null} if the lock could not be acquired
-     *          because another program holds an overlapping lock
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     * @throws  OverlappingFileLockException
-     *          If a lock that overlaps the requested region is already held by
-     *          this Java virtual machine, or if another thread is already
-     *          blocked in this method and is attempting to lock an overlapping
-     *          region
-     * @throws  NonWritableChannelException
-     *          If {@code shared} is false but this channel was not opened for writing
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     *
-     * @see     #lock(Object,CompletionHandler)
-     * @see     #lock(long,long,boolean,Object,CompletionHandler)
-     * @see     #tryLock(long,long,boolean)
-     */
-    public final FileLock tryLock() throws IOException {
-        return tryLock(0L, Long.MAX_VALUE, false);
-    }
-
-    /**
-     * Reads a sequence of bytes from this channel into the given buffer,
-     * starting at the given file position.
-     *
-     * <p> This method initiates the reading of a sequence of bytes from this
-     * channel into the given buffer, starting at the given file position. This
-     * method returns a {@code Future} representing the pending result of the
-     * operation. The Future's {@link Future#get() get} method returns the
-     * number of bytes read or {@code -1} if the given position is greater than
-     * or equal to the file's size at the time that the read is attempted.
-     *
-     * <p> This method works in the same manner as the {@link
-     * AsynchronousByteChannel#read(ByteBuffer,Object,CompletionHandler)}
-     * method, except that bytes are read starting at the given file position.
-     * If the given file position is greater than the file's size at the time
-     * that the read is attempted then no bytes are read.
-     *
-     * @param   dst
-     *          The buffer into which bytes are to be transferred
-     * @param   position
-     *          The file position at which the transfer is to begin;
-     *          must be non-negative
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  A {@code Future} object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the position is negative or the buffer is read-only
-     * @throws  NonReadableChannelException
-     *          If this channel was not opened for reading
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, the channel is closed, and the channel
-     *          was originally created with its own thread pool
-     */
-    public abstract <A> Future<Integer> read(ByteBuffer dst,
-                                             long position,
-                                             A attachment,
-                                             CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * Reads a sequence of bytes from this channel into the given buffer,
-     * starting at the given file position.
-     *
-     * <p> This method initiates the reading of a sequence of bytes from this
-     * channel into the given buffer, starting at the given file position. This
-     * method returns a {@code Future} representing the pending result of the
-     * operation. The Future's {@link Future#get() get} method returns the
-     * number of bytes read or {@code -1} if the given position is greater
-     * than or equal to the file's size at the time that the read is attempted.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #read(ByteBuffer,long,Object,CompletionHandler)} with the {@code attachment}
-     * and handler parameters set to {@code null}.
-     *
-     * @param   dst
-     *          The buffer into which bytes are to be transferred
-     * @param   position
-     *          The file position at which the transfer is to begin;
-     *          must be non-negative
-     *
-     * @return  A {@code Future} object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the position is negative or the buffer is read-only
-     * @throws  NonReadableChannelException
-     *          If this channel was not opened for reading
-     */
-    public final Future<Integer> read(ByteBuffer dst, long position) {
-        return read(dst, position, null, null);
-    }
-
-    /**
-     * Writes a sequence of bytes to this channel from the given buffer, starting
-     * at the given file position.
-     *
-     * <p> This method initiates the writing of a sequence of bytes to this channel
-     * from the given buffer, starting at the given file position. The method
-     * returns a {@code Future} representing the pending result of the write
-     * operation. The Future's {@link Future#get() get} method returns the
-     * number of bytes written.
-     *
-     * <p> This method works in the same manner as the {@link
-     * AsynchronousByteChannel#write(ByteBuffer,Object,CompletionHandler)}
-     * method, except that bytes are written starting at the given file position.
-     * If the given position is greater than the file's size, at the time that
-     * the write is attempted, then the file will be grown to accommodate the new
-     * bytes; the values of any bytes between the previous end-of-file and the
-     * newly-written bytes are unspecified.
-     *
-     * @param   src
-     *          The buffer from which bytes are to be transferred
-     * @param   position
-     *          The file position at which the transfer is to begin;
-     *          must be non-negative
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  A {@code Future} object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the position is negative
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, the channel is closed, and the channel
-     *          was originally created with its own thread pool
-     */
-    public abstract <A> Future<Integer> write(ByteBuffer src,
-                                              long position,
-                                              A attachment,
-                                              CompletionHandler<Integer,? super A> handler);
-
-    /**
-     * Writes a sequence of bytes to this channel from the given buffer, starting
-     * at the given file position.
-     *
-     * <p> This method initiates the writing of a sequence of bytes to this channel
-     * from the given buffer, starting at the given file position. The method
-     * returns a {@code Future} representing the pending result of the write
-     * operation. The Future's {@link Future#get() get} method returns the
-     * number of bytes written.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #write(ByteBuffer,long,Object,CompletionHandler)} with the {@code attachment}
-     * and handler parameters set to {@code null}.
-     *
-     * @param   src
-     *          The buffer from which bytes are to be transferred
-     * @param   position
-     *          The file position at which the transfer is to begin;
-     *          must be non-negative
-     *
-     * @return  A {@code Future} object representing the pending result
-     *
-     * @throws  IllegalArgumentException
-     *          If the position is negative
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     */
-    public final Future<Integer> write(ByteBuffer src, long position) {
-        return write(src, position, null, null);
-    }
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java	Fri Mar 06 12:26:40 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,305 +0,0 @@
-/*
- * Copyright 2007-2008 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
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package java.nio.channels;
-
-import java.net.SocketAddress;
-import java.util.concurrent.Future;
-import java.io.IOException;
-
-import java.net.SocketOption;
-import java.nio.channels.spi.AsynchronousChannelProvider;
-
-/**
- * An asynchronous channel for stream-oriented listening sockets.
- *
- * <p> An asynchronous server-socket channel is created by invoking the
- * {@link #open open} method of this class.
- * A newly-created asynchronous server-socket channel is open but not yet bound.
- * It can be bound to a local address and configured to listen for connections
- * by invoking the {@link #bind(SocketAddress,int) bind} method. Once bound,
- * the {@link #accept(Object,CompletionHandler) accept} method
- * is used to initiate the accepting of connections to the channel's socket.
- * An attempt to invoke the <tt>accept</tt> method on an unbound channel will
- * cause a {@link NotYetBoundException} to be thrown.
- *
- * <p> Channels of this type are safe for use by multiple concurrent threads
- * though at most one accept operation can be outstanding at any time.
- * If a thread initiates an accept operation before a previous accept operation
- * has completed then an {@link AcceptPendingException} will be thrown.
- *
- * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
- * setOption} method. Channels of this type support the following options:
- * <blockquote>
- * <table border>
- *   <tr>
- *     <th>Option Name</th>
- *     <th>Description</th>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_RCVBUF SO_RCVBUF} </td>
- *     <td> The size of the socket receive buffer </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_REUSEADDR SO_REUSEADDR} </td>
- *     <td> Re-use address </td>
- *   </tr>
- * </table>
- * </blockquote>
- * Additional (implementation specific) options may also be supported.
- *
- * <p> <b>Usage Example:</b>
- * <pre>
- *  final AsynchronousServerSocketChannel listener =
- *      AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(5000));
- *
- *  listener.accept(null, new CompletionHandler&lt;AsynchronousSocketChannel,Void&gt;() {
- *      public void completed(AsynchronousSocketChannel ch, Void att) {
- *          // accept the next connection
- *          listener.accept(null, this);
- *
- *          // handle this connection
- *          handle(ch);
- *      }
- *      public void failed(Throwable exc, Void att) {
- *          ...
- *      }
- *      public void cancelled(Void att) {
- *          ...
- *      }
- *  });
- * </pre>
- *
- * @since 1.7
- */
-
-public abstract class AsynchronousServerSocketChannel
-    implements AsynchronousChannel, NetworkChannel
-{
-    private final AsynchronousChannelProvider provider;
-
-    /**
-     * Initializes a new instance of this class.
-     */
-    protected AsynchronousServerSocketChannel(AsynchronousChannelProvider provider) {
-        this.provider = provider;
-    }
-
-    /**
-     * Returns the provider that created this channel.
-     */
-    public final AsynchronousChannelProvider provider() {
-        return provider;
-    }
-
-    /**
-     * Opens an asynchronous server-socket channel.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * java.nio.channels.spi.AsynchronousChannelProvider#openAsynchronousServerSocketChannel
-     * openAsynchronousServerSocketChannel} method on the {@link
-     * java.nio.channels.spi.AsynchronousChannelProvider} object that created
-     * the given group. If the group parameter is <tt>null</tt> then the
-     * resulting channel is created by the system-wide default provider, and
-     * bound to the <em>default group</em>.
-     *
-     * @param   group
-     *          The group to which the newly constructed channel should be bound,
-     *          or <tt>null</tt> for the default group
-     *
-     * @return  A new asynchronous server socket channel
-     *
-     * @throws  ShutdownChannelGroupException
-     *          If the channel group is shutdown
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public static AsynchronousServerSocketChannel open(AsynchronousChannelGroup group)
-        throws IOException
-    {
-        AsynchronousChannelProvider provider = (group == null) ?
-            AsynchronousChannelProvider.provider() : group.provider();
-        return provider.openAsynchronousServerSocketChannel(group);
-    }
-
-    /**
-     * Opens an asynchronous server-socket channel.
-     *
-     * <p> This method returns an asynchronous server socket channel that is
-     * bound to the <em>default group</em>. This method is equivalent to evaluating
-     * the expression:
-     * <blockquote><pre>
-     * open((AsynchronousChannelGroup)null);
-     * </pre></blockquote>
-     *
-     * @return  A new asynchronous server socket channel
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public static AsynchronousServerSocketChannel open()
-        throws IOException
-    {
-        return open(null);
-    }
-
-    /**
-     * Binds the channel's socket to a local address and configures the socket to
-     * listen for connections.
-     *
-     * <p> An invocation of this method is equivalent to the following:
-     * <blockquote><pre>
-     * bind(local, 0);
-     * </pre></blockquote>
-     *
-     * @param   local
-     *          The local address to bind the socket, or <tt>null</tt> to bind
-     *          to an automatically assigned socket address
-     *
-     * @return  This channel
-     *
-     * @throws  AlreadyBoundException               {@inheritDoc}
-     * @throws  UnsupportedAddressTypeException     {@inheritDoc}
-     * @throws  SecurityException                   {@inheritDoc}
-     * @throws  ClosedChannelException              {@inheritDoc}
-     * @throws  IOException                         {@inheritDoc}
-     */
-    public final AsynchronousServerSocketChannel bind(SocketAddress local)
-        throws IOException
-    {
-        return bind(local, 0);
-    }
-
-    /**
-     * Binds the channel's socket to a local address and configures the socket to
-     * listen for connections.
-     *
-     * <p> This method is used to establish an association between the socket and
-     * a local address. Once an association is established then the socket remains
-     * bound until the associated channel is closed.
-     *
-     * <p> The {@code backlog} parameter is the maximum number of pending
-     * connections on the socket. Its exact semantics are implementation specific.
-     * In particular, an implementation may impose a maximum length or may choose
-     * to ignore the parameter altogther. If the {@code backlog} parameter has
-     * the value {@code 0}, or a negative value, then an implementation specific
-     * default is used.
-     *
-     * @param   local
-     *          The local address to bind the socket, or {@code null} to bind
-     *          to an automatically assigned socket address
-     * @param   backlog
-     *          The maximum number of pending connections
-     *
-     * @return  This channel
-     *
-     * @throws  AlreadyBoundException
-     *          If the socket is already bound
-     * @throws  UnsupportedAddressTypeException
-     *          If the type of the given address is not supported
-     * @throws  SecurityException
-     *          If a security manager has been installed and its {@link
-     *          SecurityManager#checkListen checkListen} method denies the operation
-     * @throws  ClosedChannelException
-     *          If the channel is closed
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract AsynchronousServerSocketChannel bind(SocketAddress local, int backlog)
-        throws IOException;
-
-    /**
-     * @throws  IllegalArgumentException                {@inheritDoc}
-     * @throws  ClosedChannelException                  {@inheritDoc}
-     * @throws  IOException                             {@inheritDoc}
-     */
-    public abstract <T> AsynchronousServerSocketChannel setOption(SocketOption<T> name, T value)
-        throws IOException;
-
-    /**
-     * Accepts a connection.
-     *
-     * <p> This method initiates accepting a connection made to this channel's
-     * socket, returning a {@link Future} representing the pending result
-     * of the operation. The {@code Future}'s {@link Future#get() get}
-     * method will return the {@link AsynchronousSocketChannel} for the new
-     * connection on successful completion.
-     *
-     * <p> When a new connection is accepted then the resulting {@code
-     * AsynchronousSocketChannel} will be bound to the same {@link
-     * AsynchronousChannelGroup} as this channel. If the group is {@link
-     * AsynchronousChannelGroup#isShutdown shutdown} and a connection is accepted,
-     * then the connection is closed, and the operation completes with an {@code
-     * IOException} and cause {@link ShutdownChannelGroupException}.
-     *
-     * <p> To allow for concurrent handling of new connections, the completion
-     * handler is not invoked directly by the initiating thread when a new
-     * connection is accepted immediately (see <a
-     * href="AsynchronousChannelGroup.html#threading">Threading<a>).
-     *
-     * <p> If a security manager has been installed then it verifies that the
-     * address and port number of the connection's remote endpoint are permitted
-     * by the security manager's {@link SecurityManager#checkAccept checkAccept}
-     * method. The permission check is performed with privileges that are restricted
-     * by the calling context of this method. If the permission check fails then
-     * the connection is closed and the operation completes with a {@link
-     * SecurityException}.
-     *
-     * @param   attachment
-     *          The object to attach to the I/O operation; can be {@code null}
-     * @param   handler
-     *          The handler for consuming the result; can be {@code null}
-     *
-     * @return  an <tt>Future</tt> object representing the pending result
-     *
-     * @throws  AcceptPendingException
-     *          If an accept operation is already in progress on this channel
-     * @throws  NotYetBoundException
-     *          If this channel's socket has not yet been bound
-     * @throws  ShutdownChannelGroupException
-     *          If a handler is specified, and the channel group is shutdown
-     */
-    public abstract <A> Future<AsynchronousSocketChannel>
-        accept(A attachment, CompletionHandler<AsynchronousSocketChannel,? super A> handler);
-
-    /**
-     * Accepts a connection.
-     *
-     * <p> This method is equivalent to invoking {@link
-     * #accept(Object,CompletionHandler)} with the {@code attachment}
-     * and {@code handler} parameters set to {@code null}.
-     *
-     * @return  an <tt>Future</tt> object representing the pending result
-     *
-     * @throws  AcceptPendingException
-     *          If an accept operation is already in progress on this channel
-     * @throws  NotYetBoundException
-     *          If this channel's socket has not yet been bound
-     */
-    public final Future<AsynchronousSocketChannel> accept() {
-        return accept(null, null);
-    }
-}