FOREIGN MODULE java_nio_channels;

IMPORT
    java_lang := "java.lang",
    java_io := "java.io",
    java_nio := "java.nio",
    java_nio_channels_spi := "java.nio.channels.spi",
    sun_nio_ch := "sun.nio.ch",
    java_nio_charset := "java.nio.charset",
    java_net := "java.net",
    java_util := "java.util";

TYPE

  AlreadyConnectedException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                               STATIC
                                 PROCEDURE Init*() : AlreadyConnectedException,CONSTRUCTOR;
                               END;

  AsynchronousCloseException* = POINTER TO EXTENSIBLE RECORD (ClosedChannelException)
                                STATIC
                                  PROCEDURE Init*() : AsynchronousCloseException,CONSTRUCTOR;
                                END;

  ByteChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + ReadableByteChannel + WritableByteChannel)
                 END;

  CancelledKeyException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                           STATIC
                             PROCEDURE Init*() : CancelledKeyException,CONSTRUCTOR;
                           END;

  Channel* = POINTER TO INTERFACE RECORD (java_lang.Object + java_io.Closeable)    (* Typebound Procedures *)
             END;

  Channels* = POINTER TO RECORD (java_lang.Object)
              STATIC
                PROCEDURE newChannel*(p0 : java_io.InputStream) : ReadableByteChannel;
                PROCEDURE newChannel*(p0 : java_io.OutputStream) : WritableByteChannel;
                PROCEDURE newInputStream*(p0 : ReadableByteChannel) : java_io.InputStream;
                PROCEDURE newOutputStream*(p0 : WritableByteChannel) : java_io.OutputStream;
                PROCEDURE newReader*(p0 : ReadableByteChannel;
                                     p1 : java_lang.String) : java_io.Reader;
                PROCEDURE newReader*(p0 : ReadableByteChannel;
                                     p1 : java_nio_charset.CharsetDecoder;
                                     p2 : INTEGER) : java_io.Reader;
                PROCEDURE newWriter*(p0 : WritableByteChannel;
                                     p1 : java_lang.String) : java_io.Writer;
                PROCEDURE newWriter*(p0 : WritableByteChannel;
                                     p1 : java_nio_charset.CharsetEncoder;
                                     p2 : INTEGER) : java_io.Writer;
              END;

  ClosedByInterruptException* = POINTER TO EXTENSIBLE RECORD (AsynchronousCloseException)
                                STATIC
                                  PROCEDURE Init*() : ClosedByInterruptException,CONSTRUCTOR;
                                END;

  ClosedChannelException* = POINTER TO EXTENSIBLE RECORD (java_io.IOException)
                            STATIC
                              PROCEDURE Init*() : ClosedChannelException,CONSTRUCTOR;
                            END;

  ClosedSelectorException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                             STATIC
                               PROCEDURE Init*() : ClosedSelectorException,CONSTRUCTOR;
                             END;

  ConnectionPendingException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                STATIC
                                  PROCEDURE Init*() : ConnectionPendingException,CONSTRUCTOR;
                                END;

  DatagramChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractSelectableChannel + ByteChannel + ScatteringByteChannel + GatheringByteChannel)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init!(p0 : java_nio_channels_spi.SelectorProvider) : DatagramChannel,CONSTRUCTOR;
                       PROCEDURE open*() : DatagramChannel;
                     END;

  FileChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractInterruptibleChannel + ByteChannel + GatheringByteChannel + ScatteringByteChannel)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init!() : FileChannel,CONSTRUCTOR;
                 END;

  FileChannel$MapMode* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                         STATIC
                           PRIVATE*    : FileChannel$MapMode;
                           READ_ONLY*  : FileChannel$MapMode;
                           READ_WRITE* : FileChannel$MapMode;
                         END;

  FileLock* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
              STATIC
                PROCEDURE Init!(p0 : FileChannel;
                                p1 : LONGINT;
                                p2 : LONGINT;
                                p3 : BOOLEAN) : FileLock,CONSTRUCTOR;
              END;

  FileLockInterruptionException* = POINTER TO EXTENSIBLE RECORD (java_io.IOException)
                                   STATIC
                                     PROCEDURE Init*() : FileLockInterruptionException,CONSTRUCTOR;
                                   END;

  GatheringByteChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + WritableByteChannel)    (* Typebound Procedures *)
                          END;

  IllegalBlockingModeException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                  STATIC
                                    PROCEDURE Init*() : IllegalBlockingModeException,CONSTRUCTOR;
                                  END;

  IllegalSelectorException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalArgumentException)
                              STATIC
                                PROCEDURE Init*() : IllegalSelectorException,CONSTRUCTOR;
                              END;

  InterruptibleChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + Channel)    (* Typebound Procedures *)
                          END;

  NoConnectionPendingException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                  STATIC
                                    PROCEDURE Init*() : NoConnectionPendingException,CONSTRUCTOR;
                                  END;

  NonReadableChannelException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                 STATIC
                                   PROCEDURE Init*() : NonReadableChannelException,CONSTRUCTOR;
                                 END;

  NonWritableChannelException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                 STATIC
                                   PROCEDURE Init*() : NonWritableChannelException,CONSTRUCTOR;
                                 END;

  NotYetBoundException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                          STATIC
                            PROCEDURE Init*() : NotYetBoundException,CONSTRUCTOR;
                          END;

  NotYetConnectedException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                              STATIC
                                PROCEDURE Init*() : NotYetConnectedException,CONSTRUCTOR;
                              END;

  OverlappingFileLockException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                                  STATIC
                                    PROCEDURE Init*() : OverlappingFileLockException,CONSTRUCTOR;
                                  END;

  Pipe* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
          STATIC
            PROCEDURE Init!() : Pipe,CONSTRUCTOR;
            PROCEDURE open*() : Pipe;
          END;

  Pipe$SinkChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractSelectableChannel + WritableByteChannel + GatheringByteChannel)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE Init!(p0 : java_nio_channels_spi.SelectorProvider) : Pipe$SinkChannel,CONSTRUCTOR;
                      END;

  Pipe$SourceChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractSelectableChannel + ReadableByteChannel + ScatteringByteChannel)    (* Typebound Procedures *)
                        STATIC
                          PROCEDURE Init!(p0 : java_nio_channels_spi.SelectorProvider) : Pipe$SourceChannel,CONSTRUCTOR;
                        END;

  ReadableByteChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + Channel)    (* Typebound Procedures *)
                         END;

  ScatteringByteChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + ReadableByteChannel)    (* Typebound Procedures *)
                           END;

  SelectableChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractInterruptibleChannel + Channel)    (* Typebound Procedures *)
                       STATIC
                         PROCEDURE Init!() : SelectableChannel,CONSTRUCTOR;
                       END;

  SelectionKey* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                  STATIC
                    OP_ACCEPT*  = 16;
                    OP_CONNECT* = 8;
                    OP_READ*    = 1;
                    OP_WRITE*   = 4;
                    PROCEDURE Init!() : SelectionKey,CONSTRUCTOR;
                  END;

  Selector* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
              STATIC
                PROCEDURE Init!() : Selector,CONSTRUCTOR;
                PROCEDURE open*() : Selector;
              END;

  ServerSocketChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractSelectableChannel)    (* Typebound Procedures *)
                         STATIC
                           PROCEDURE Init!(p0 : java_nio_channels_spi.SelectorProvider) : ServerSocketChannel,CONSTRUCTOR;
                           PROCEDURE open*() : ServerSocketChannel;
                         END;

  SocketChannel* = POINTER TO ABSTRACT RECORD (java_nio_channels_spi.AbstractSelectableChannel + ByteChannel + ScatteringByteChannel + GatheringByteChannel)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init!(p0 : java_nio_channels_spi.SelectorProvider) : SocketChannel,CONSTRUCTOR;
                     PROCEDURE open*(p0 : java_net.SocketAddress) : SocketChannel;
                     PROCEDURE open*() : SocketChannel;
                   END;

  UnresolvedAddressException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalArgumentException)
                                STATIC
                                  PROCEDURE Init*() : UnresolvedAddressException,CONSTRUCTOR;
                                END;

  UnsupportedAddressTypeException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalArgumentException)
                                     STATIC
                                       PROCEDURE Init*() : UnsupportedAddressTypeException,CONSTRUCTOR;
                                     END;

  WritableByteChannel* = POINTER TO INTERFACE RECORD (java_lang.Object + Channel)    (* Typebound Procedures *)
                         END;




PROCEDURE (self:Channel) close*(),NEW,ABSTRACT;

PROCEDURE (self:Channel) isOpen*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) connect*(p0 : java_net.SocketAddress) : DatagramChannel,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) disconnect*() : DatagramChannel,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) isConnected*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) read*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:DatagramChannel) receive*(p0 : java_nio.ByteBuffer) : java_net.SocketAddress,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) send*(p0 : java_nio.ByteBuffer;
                                       p1 : java_net.SocketAddress) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) socket*() : java_net.DatagramSocket,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) validOps*() : INTEGER;

PROCEDURE (self:DatagramChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:DatagramChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                            p1 : INTEGER;
                                            p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:DatagramChannel) write*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) force*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:FileChannel) lock*(p0 : LONGINT;
                                   p1 : LONGINT;
                                   p2 : BOOLEAN) : FileLock,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) lock*() : FileLock,NEW;

PROCEDURE (self:FileChannel) map*(p0 : FileChannel$MapMode;
                                  p1 : LONGINT;
                                  p2 : LONGINT) : java_nio.MappedByteBuffer,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) position*(p0 : LONGINT) : FileChannel,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) position*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) read*(p0 : java_nio.ByteBuffer;
                                   p1 : LONGINT) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) read*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:FileChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) size*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) transferFrom*(p0 : ReadableByteChannel;
                                           p1 : LONGINT;
                                           p2 : LONGINT) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) transferTo*(p0 : LONGINT;
                                         p1 : LONGINT;
                                         p2 : WritableByteChannel) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) truncate*(p0 : LONGINT) : FileChannel,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) tryLock*(p0 : LONGINT;
                                      p1 : LONGINT;
                                      p2 : BOOLEAN) : FileLock,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) tryLock*() : FileLock,NEW;

PROCEDURE (self:FileChannel) write*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) write*(p0 : java_nio.ByteBuffer;
                                    p1 : LONGINT) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:FileChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:FileChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                        p1 : INTEGER;
                                        p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:FileChannel$MapMode) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:FileLock) channel*() : FileChannel,NEW;

PROCEDURE (self:FileLock) isShared*() : BOOLEAN,NEW;

PROCEDURE (self:FileLock) isValid*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:FileLock) overlaps*(p0 : LONGINT;
                                    p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:FileLock) position*() : LONGINT,NEW;

PROCEDURE (self:FileLock) release*(),NEW,ABSTRACT;

PROCEDURE (self:FileLock) size*() : LONGINT,NEW;

PROCEDURE (self:FileLock) toString*() : java_lang.String;

PROCEDURE (self:GatheringByteChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:GatheringByteChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:InterruptibleChannel) close*(),NEW,ABSTRACT;

PROCEDURE (self:Pipe) sink*() : Pipe$SinkChannel,NEW,ABSTRACT;

PROCEDURE (self:Pipe) source*() : Pipe$SourceChannel,NEW,ABSTRACT;

PROCEDURE (self:Pipe$SinkChannel) validOps*() : INTEGER;

PROCEDURE (self:Pipe$SourceChannel) validOps*() : INTEGER;

PROCEDURE (self:ReadableByteChannel) read*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ScatteringByteChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:ScatteringByteChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) blockingLock*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) configureBlocking*(p0 : BOOLEAN) : SelectableChannel,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) isBlocking*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) isRegistered*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) keyFor*(p0 : Selector) : SelectionKey,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) provider*() : java_nio_channels_spi.SelectorProvider,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) register*(p0 : Selector;
                                             p1 : INTEGER;
                                             p2 : java_lang.Object) : SelectionKey,NEW,ABSTRACT;

PROCEDURE (self:SelectableChannel) register*(p0 : Selector;
                                             p1 : INTEGER) : SelectionKey,NEW;

PROCEDURE (self:SelectableChannel) validOps*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) attach*(p0 : java_lang.Object) : java_lang.Object,NEW;

PROCEDURE (self:SelectionKey) attachment*() : java_lang.Object,NEW;

PROCEDURE (self:SelectionKey) cancel*(),NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) channel*() : SelectableChannel,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) interestOps*(p0 : INTEGER) : SelectionKey,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) interestOps*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) isAcceptable*() : BOOLEAN,NEW;

PROCEDURE (self:SelectionKey) isConnectable*() : BOOLEAN,NEW;

PROCEDURE (self:SelectionKey) isReadable*() : BOOLEAN,NEW;

PROCEDURE (self:SelectionKey) isValid*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) isWritable*() : BOOLEAN,NEW;

PROCEDURE (self:SelectionKey) readyOps*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SelectionKey) selector*() : Selector,NEW,ABSTRACT;

PROCEDURE (self:Selector) close*(),NEW,ABSTRACT;

PROCEDURE (self:Selector) isOpen*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Selector) keys*() : java_util.Set,NEW,ABSTRACT;

PROCEDURE (self:Selector) provider*() : java_nio_channels_spi.SelectorProvider,NEW,ABSTRACT;

PROCEDURE (self:Selector) select*(p0 : LONGINT) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Selector) select*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Selector) selectedKeys*() : java_util.Set,NEW,ABSTRACT;

PROCEDURE (self:Selector) selectNow*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Selector) wakeup*() : Selector,NEW,ABSTRACT;

PROCEDURE (self:ServerSocketChannel) accept*() : SocketChannel,NEW,ABSTRACT;

PROCEDURE (self:ServerSocketChannel) socket*() : java_net.ServerSocket,NEW,ABSTRACT;

PROCEDURE (self:ServerSocketChannel) validOps*() : INTEGER;

PROCEDURE (self:SocketChannel) connect*(p0 : java_net.SocketAddress) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) finishConnect*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) isConnected*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) isConnectionPending*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) read*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:SocketChannel) read*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) socket*() : java_net.Socket,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) validOps*() : INTEGER;

PROCEDURE (self:SocketChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer) : LONGINT,NEW;

PROCEDURE (self:SocketChannel) write*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                          p1 : INTEGER;
                                          p2 : INTEGER) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:SocketChannel) write*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:WritableByteChannel) write*(p0 : java_nio.ByteBuffer) : INTEGER,NEW,ABSTRACT;

END java_nio_channels.