From b3c1eef2a77b9f68a37a905bf29f28f0e6ab9a32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E8=8B=B1=E6=9D=B0?= <327782001@qq.com> Date: Mon, 3 Apr 2023 14:54:39 +0800 Subject: [PATCH] =?UTF-8?q?fix:=E6=B7=BB=E5=8A=A0=E9=87=8D=E5=86=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- out/production/classes1/.idea/.gitignore | 8 + .../classes1/.idea/easyCodeTableSetting.xml | 661 ++++++++ .../inspectionProfiles/Project_Default.xml | 38 + out/production/classes1/.idea/misc.xml | 6 + out/production/classes1/.idea/modules.xml | 8 + out/production/classes1/.idea/vcs.xml | 6 + out/production/classes1/READEME.md | 0 out/production/classes1/applet/package.html | 60 + .../classes1/awt/color/package.html | 55 + .../classes1/awt/datatransfer/package.html | 64 + out/production/classes1/awt/dnd/package.html | 146 ++ .../classes1/awt/dnd/peer/package.html | 51 + .../awt/doc-files/AWTThreadIssues.html | 193 +++ .../classes1/awt/doc-files/BorderLayout-1.gif | Bin 0 -> 2716 bytes .../classes1/awt/doc-files/Button-1.gif | Bin 0 -> 1920 bytes .../classes1/awt/doc-files/Checkbox-1.gif | Bin 0 -> 2375 bytes .../awt/doc-files/CheckboxGroup-1.gif | Bin 0 -> 712 bytes .../classes1/awt/doc-files/Choice-1.gif | Bin 0 -> 486 bytes .../awt/doc-files/DesktopProperties.html | 277 +++ .../classes1/awt/doc-files/FlowLayout-1.gif | Bin 0 -> 1918 bytes .../classes1/awt/doc-files/FocusCycle.gif | Bin 0 -> 6933 bytes .../classes1/awt/doc-files/FocusSpec.html | 1367 +++++++++++++++ .../classes1/awt/doc-files/FontMetrics-1.gif | Bin 0 -> 290 bytes .../awt/doc-files/GridBagLayout-1.gif | Bin 0 -> 2608 bytes .../awt/doc-files/GridBagLayout-2.gif | Bin 0 -> 2592 bytes .../awt/doc-files/GridBagLayout-baseline.png | Bin 0 -> 722 bytes .../classes1/awt/doc-files/GridLayout-1.gif | Bin 0 -> 1764 bytes .../classes1/awt/doc-files/GridLayout-2.gif | Bin 0 -> 1776 bytes .../awt/doc-files/ImplicitFocusTransfer.gif | Bin 0 -> 5151 bytes .../classes1/awt/doc-files/Label-1.gif | Bin 0 -> 819 bytes .../awt/doc-files/LinearGradientPaint.png | Bin 0 -> 3347 bytes .../classes1/awt/doc-files/List-1.gif | Bin 0 -> 4193 bytes .../classes1/awt/doc-files/MenuBar-1.gif | Bin 0 -> 2268 bytes .../classes1/awt/doc-files/Modality.html | 471 ++++++ .../classes1/awt/doc-files/MultiScreen.gif | Bin 0 -> 3131 bytes .../awt/doc-files/RadialGradientPaint-1.png | Bin 0 -> 21911 bytes .../awt/doc-files/RadialGradientPaint-2.png | Bin 0 -> 25468 bytes .../awt/doc-files/RadialGradientPaint-3.png | Bin 0 -> 14389 bytes .../awt/doc-files/RadialGradientPaint-4.png | Bin 0 -> 9784 bytes .../classes1/awt/doc-files/Scrollbar-1.gif | Bin 0 -> 968 bytes .../classes1/awt/doc-files/Scrollbar-2.gif | Bin 0 -> 1938 bytes .../classes1/awt/doc-files/TextArea-1.gif | Bin 0 -> 2234 bytes .../classes1/awt/doc-files/TextField-1.gif | Bin 0 -> 2522 bytes .../classes1/awt/doc-files/modal-example1.gif | Bin 0 -> 2175 bytes .../classes1/awt/doc-files/modal-example2.gif | Bin 0 -> 2353 bytes .../classes1/awt/doc-files/modal-example3.gif | Bin 0 -> 2822 bytes .../classes1/awt/doc-files/modal-example4.gif | Bin 0 -> 2868 bytes .../classes1/awt/event/package.html | 58 + out/production/classes1/awt/font/package.html | 53 + out/production/classes1/awt/geom/package.html | 63 + out/production/classes1/awt/im/package.html | 69 + .../classes1/awt/im/spi/package.html | 126 ++ .../classes1/awt/image/package.html | 58 + .../awt/image/renderable/package.html | 52 + out/production/classes1/awt/package.html | 83 + out/production/classes1/awt/peer/package.html | 51 + .../classes1/awt/print/package.html | 58 + .../classes1/beans/beancontext/package.html | 55 + out/production/classes1/beans/package.html | 156 ++ out/production/classes1/classes.iml | 11 + out/production/classes1/classes1.iml | 11 + out/production/classes1/io/package.html | 52 + .../classes1/lang/doc-files/ValueBased.html | 42 + .../classes1/lang/doc-files/capchi.gif | Bin 0 -> 144 bytes .../classes1/lang/doc-files/capiota.gif | Bin 0 -> 111 bytes .../classes1/lang/doc-files/capsigma.gif | Bin 0 -> 131 bytes .../classes1/lang/doc-files/captheta.gif | Bin 0 -> 153 bytes .../classes1/lang/doc-files/capupsil.gif | Bin 0 -> 140 bytes .../classes1/lang/doc-files/chi.gif | Bin 0 -> 145 bytes .../classes1/lang/doc-files/iota.gif | Bin 0 -> 112 bytes .../lang/doc-files/javalang.doc.anc21.gif | Bin 0 -> 206 bytes .../lang/doc-files/javalang.doc.anc38.gif | Bin 0 -> 220 bytes .../lang/doc-files/javalang.doc.anc40.gif | Bin 0 -> 187 bytes .../lang/doc-files/javalang.doc.anc41.gif | Bin 0 -> 191 bytes .../classes1/lang/doc-files/sigma1.gif | Bin 0 -> 135 bytes .../classes1/lang/doc-files/theta.gif | Bin 0 -> 144 bytes .../classes1/lang/doc-files/upsilon.gif | Bin 0 -> 133 bytes .../classes1/lang/instrument/package.html | 281 +++ .../classes1/lang/management/package.html | 248 +++ out/production/classes1/lang/ref/package.html | 147 ++ .../net/doc-files/net-properties.html | 242 +++ .../nio/ByteBufferAs-X-Buffer.java.template | 225 +++ .../nio/Direct-X-Buffer-bin.java.template | 124 ++ .../nio/Direct-X-Buffer.java.template | 490 ++++++ .../classes1/nio/Heap-X-Buffer.java.template | 601 +++++++ .../classes1/nio/X-Buffer-bin.java.template | 132 ++ .../classes1/nio/X-Buffer.java.template | 1503 +++++++++++++++++ .../classes1/nio/channels/exceptions | 194 +++ .../classes1/nio/channels/spi/package.html | 45 + .../nio/charset/Charset-X-Coder.java.template | 996 +++++++++++ .../classes1/nio/charset/exceptions | 53 + .../classes1/nio/charset/package.html | 88 + .../classes1/nio/charset/spi/package.html | 45 + out/production/classes1/nio/exceptions | 60 + out/production/classes1/nio/package.html | 139 ++ .../classes1/rmi/activation/package.html | 61 + out/production/classes1/rmi/dgc/package.html | 55 + out/production/classes1/rmi/package.html | 59 + .../classes1/rmi/registry/package.html | 57 + .../classes1/rmi/server/package.html | 74 + out/production/classes1/sql/package.html | 340 ++++ out/production/classes1/text/package.html | 65 + out/production/classes1/text/spi/package.html | 50 + out/production/classes1/time/overview.html | 169 ++ .../classes1/util/CurrencyData.properties | 598 +++++++ out/production/classes1/util/jar/package.html | 63 + .../classes1/util/logging/package.html | 134 ++ out/production/classes1/util/package.html | 55 + .../classes1/util/prefs/package.html | 44 + .../classes1/util/regex/package.html | 66 + out/production/classes1/util/spi/package.html | 50 + out/production/classes1/util/zip/package.html | 98 ++ util/HashMap.java | 931 +++++----- 113 files changed, 12586 insertions(+), 405 deletions(-) create mode 100644 out/production/classes1/.idea/.gitignore create mode 100644 out/production/classes1/.idea/easyCodeTableSetting.xml create mode 100644 out/production/classes1/.idea/inspectionProfiles/Project_Default.xml create mode 100644 out/production/classes1/.idea/misc.xml create mode 100644 out/production/classes1/.idea/modules.xml create mode 100644 out/production/classes1/.idea/vcs.xml create mode 100644 out/production/classes1/READEME.md create mode 100644 out/production/classes1/applet/package.html create mode 100644 out/production/classes1/awt/color/package.html create mode 100644 out/production/classes1/awt/datatransfer/package.html create mode 100644 out/production/classes1/awt/dnd/package.html create mode 100644 out/production/classes1/awt/dnd/peer/package.html create mode 100644 out/production/classes1/awt/doc-files/AWTThreadIssues.html create mode 100644 out/production/classes1/awt/doc-files/BorderLayout-1.gif create mode 100644 out/production/classes1/awt/doc-files/Button-1.gif create mode 100644 out/production/classes1/awt/doc-files/Checkbox-1.gif create mode 100644 out/production/classes1/awt/doc-files/CheckboxGroup-1.gif create mode 100644 out/production/classes1/awt/doc-files/Choice-1.gif create mode 100644 out/production/classes1/awt/doc-files/DesktopProperties.html create mode 100644 out/production/classes1/awt/doc-files/FlowLayout-1.gif create mode 100644 out/production/classes1/awt/doc-files/FocusCycle.gif create mode 100644 out/production/classes1/awt/doc-files/FocusSpec.html create mode 100644 out/production/classes1/awt/doc-files/FontMetrics-1.gif create mode 100644 out/production/classes1/awt/doc-files/GridBagLayout-1.gif create mode 100644 out/production/classes1/awt/doc-files/GridBagLayout-2.gif create mode 100644 out/production/classes1/awt/doc-files/GridBagLayout-baseline.png create mode 100644 out/production/classes1/awt/doc-files/GridLayout-1.gif create mode 100644 out/production/classes1/awt/doc-files/GridLayout-2.gif create mode 100644 out/production/classes1/awt/doc-files/ImplicitFocusTransfer.gif create mode 100644 out/production/classes1/awt/doc-files/Label-1.gif create mode 100644 out/production/classes1/awt/doc-files/LinearGradientPaint.png create mode 100644 out/production/classes1/awt/doc-files/List-1.gif create mode 100644 out/production/classes1/awt/doc-files/MenuBar-1.gif create mode 100644 out/production/classes1/awt/doc-files/Modality.html create mode 100644 out/production/classes1/awt/doc-files/MultiScreen.gif create mode 100644 out/production/classes1/awt/doc-files/RadialGradientPaint-1.png create mode 100644 out/production/classes1/awt/doc-files/RadialGradientPaint-2.png create mode 100644 out/production/classes1/awt/doc-files/RadialGradientPaint-3.png create mode 100644 out/production/classes1/awt/doc-files/RadialGradientPaint-4.png create mode 100644 out/production/classes1/awt/doc-files/Scrollbar-1.gif create mode 100644 out/production/classes1/awt/doc-files/Scrollbar-2.gif create mode 100644 out/production/classes1/awt/doc-files/TextArea-1.gif create mode 100644 out/production/classes1/awt/doc-files/TextField-1.gif create mode 100644 out/production/classes1/awt/doc-files/modal-example1.gif create mode 100644 out/production/classes1/awt/doc-files/modal-example2.gif create mode 100644 out/production/classes1/awt/doc-files/modal-example3.gif create mode 100644 out/production/classes1/awt/doc-files/modal-example4.gif create mode 100644 out/production/classes1/awt/event/package.html create mode 100644 out/production/classes1/awt/font/package.html create mode 100644 out/production/classes1/awt/geom/package.html create mode 100644 out/production/classes1/awt/im/package.html create mode 100644 out/production/classes1/awt/im/spi/package.html create mode 100644 out/production/classes1/awt/image/package.html create mode 100644 out/production/classes1/awt/image/renderable/package.html create mode 100644 out/production/classes1/awt/package.html create mode 100644 out/production/classes1/awt/peer/package.html create mode 100644 out/production/classes1/awt/print/package.html create mode 100644 out/production/classes1/beans/beancontext/package.html create mode 100644 out/production/classes1/beans/package.html create mode 100644 out/production/classes1/classes.iml create mode 100644 out/production/classes1/classes1.iml create mode 100644 out/production/classes1/io/package.html create mode 100644 out/production/classes1/lang/doc-files/ValueBased.html create mode 100644 out/production/classes1/lang/doc-files/capchi.gif create mode 100644 out/production/classes1/lang/doc-files/capiota.gif create mode 100644 out/production/classes1/lang/doc-files/capsigma.gif create mode 100644 out/production/classes1/lang/doc-files/captheta.gif create mode 100644 out/production/classes1/lang/doc-files/capupsil.gif create mode 100644 out/production/classes1/lang/doc-files/chi.gif create mode 100644 out/production/classes1/lang/doc-files/iota.gif create mode 100644 out/production/classes1/lang/doc-files/javalang.doc.anc21.gif create mode 100644 out/production/classes1/lang/doc-files/javalang.doc.anc38.gif create mode 100644 out/production/classes1/lang/doc-files/javalang.doc.anc40.gif create mode 100644 out/production/classes1/lang/doc-files/javalang.doc.anc41.gif create mode 100644 out/production/classes1/lang/doc-files/sigma1.gif create mode 100644 out/production/classes1/lang/doc-files/theta.gif create mode 100644 out/production/classes1/lang/doc-files/upsilon.gif create mode 100644 out/production/classes1/lang/instrument/package.html create mode 100644 out/production/classes1/lang/management/package.html create mode 100644 out/production/classes1/lang/ref/package.html create mode 100644 out/production/classes1/net/doc-files/net-properties.html create mode 100644 out/production/classes1/nio/ByteBufferAs-X-Buffer.java.template create mode 100644 out/production/classes1/nio/Direct-X-Buffer-bin.java.template create mode 100644 out/production/classes1/nio/Direct-X-Buffer.java.template create mode 100644 out/production/classes1/nio/Heap-X-Buffer.java.template create mode 100644 out/production/classes1/nio/X-Buffer-bin.java.template create mode 100644 out/production/classes1/nio/X-Buffer.java.template create mode 100644 out/production/classes1/nio/channels/exceptions create mode 100644 out/production/classes1/nio/channels/spi/package.html create mode 100644 out/production/classes1/nio/charset/Charset-X-Coder.java.template create mode 100644 out/production/classes1/nio/charset/exceptions create mode 100644 out/production/classes1/nio/charset/package.html create mode 100644 out/production/classes1/nio/charset/spi/package.html create mode 100644 out/production/classes1/nio/exceptions create mode 100644 out/production/classes1/nio/package.html create mode 100644 out/production/classes1/rmi/activation/package.html create mode 100644 out/production/classes1/rmi/dgc/package.html create mode 100644 out/production/classes1/rmi/package.html create mode 100644 out/production/classes1/rmi/registry/package.html create mode 100644 out/production/classes1/rmi/server/package.html create mode 100644 out/production/classes1/sql/package.html create mode 100644 out/production/classes1/text/package.html create mode 100644 out/production/classes1/text/spi/package.html create mode 100644 out/production/classes1/time/overview.html create mode 100644 out/production/classes1/util/CurrencyData.properties create mode 100644 out/production/classes1/util/jar/package.html create mode 100644 out/production/classes1/util/logging/package.html create mode 100644 out/production/classes1/util/package.html create mode 100644 out/production/classes1/util/prefs/package.html create mode 100644 out/production/classes1/util/regex/package.html create mode 100644 out/production/classes1/util/spi/package.html create mode 100644 out/production/classes1/util/zip/package.html diff --git a/out/production/classes1/.idea/.gitignore b/out/production/classes1/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/out/production/classes1/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/out/production/classes1/.idea/easyCodeTableSetting.xml b/out/production/classes1/.idea/easyCodeTableSetting.xml new file mode 100644 index 0000000..a374cc5 --- /dev/null +++ b/out/production/classes1/.idea/easyCodeTableSetting.xml @@ -0,0 +1,661 @@ + + + + + + \ No newline at end of file diff --git a/out/production/classes1/.idea/inspectionProfiles/Project_Default.xml b/out/production/classes1/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..192591c --- /dev/null +++ b/out/production/classes1/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,38 @@ + + + + \ No newline at end of file diff --git a/out/production/classes1/.idea/misc.xml b/out/production/classes1/.idea/misc.xml new file mode 100644 index 0000000..05c7214 --- /dev/null +++ b/out/production/classes1/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/out/production/classes1/.idea/modules.xml b/out/production/classes1/.idea/modules.xml new file mode 100644 index 0000000..4afc44e --- /dev/null +++ b/out/production/classes1/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/out/production/classes1/.idea/vcs.xml b/out/production/classes1/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/out/production/classes1/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/out/production/classes1/READEME.md b/out/production/classes1/READEME.md new file mode 100644 index 0000000..e69de29 diff --git a/out/production/classes1/applet/package.html b/out/production/classes1/applet/package.html new file mode 100644 index 0000000..18c9628 --- /dev/null +++ b/out/production/classes1/applet/package.html @@ -0,0 +1,60 @@ + + + + + + +Provides the classes necessary to create an applet and the classes an applet +uses to communicate with its applet context. +

+The applet framework involves two +entities: the applet and the applet context. An applet is an +embeddable window (see the Panel class) with a few extra methods that the applet +context can use to initialize, start, and stop the applet. +

+The applet context is an application that is responsible for loading and running +applets. For example, the applet context could be a Web browser or an applet +development environment. +

+ + +@since JDK1.0 + + diff --git a/out/production/classes1/awt/color/package.html b/out/production/classes1/awt/color/package.html new file mode 100644 index 0000000..41fa95a --- /dev/null +++ b/out/production/classes1/awt/color/package.html @@ -0,0 +1,55 @@ + + + + + + + +Provides classes for color spaces. It contains an +implementation of a color space based on the International Color +Consortium (ICC) Profile Format Specification, Version 3.4, August 15, +1997. It also contains color profiles based on the ICC Profile Format +Specification. + + + +@since 1.2 + + diff --git a/out/production/classes1/awt/datatransfer/package.html b/out/production/classes1/awt/datatransfer/package.html new file mode 100644 index 0000000..abaf6b8 --- /dev/null +++ b/out/production/classes1/awt/datatransfer/package.html @@ -0,0 +1,64 @@ + + + + + + + +Provides interfaces and classes for transferring data +between and within applications. It defines the notion of a +"transferable" object, which is an object capable of being +transferred between or within applications. An object identifies +itself as being transferable by implementing the Transferable +interface. +

+It also provides a clipboard mechanism, which is an object that +temporarily holds a transferable object that can be transferred +between or within an application. The clipboard is typically used +for copy and paste operations. Although it is possible to create +a clipboard to use within an application, most applications will +use the system clipboard to ensure the data can be transferred +across applications running on the platform. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/awt/dnd/package.html b/out/production/classes1/awt/dnd/package.html new file mode 100644 index 0000000..4673485 --- /dev/null +++ b/out/production/classes1/awt/dnd/package.html @@ -0,0 +1,146 @@ + + + + + + + +Drag and Drop is a direct manipulation gesture found in many Graphical +User Interface systems that provides a mechanism to transfer +information between two entities logically associated with presentation +elements in the GUI. Normally driven by a physical gesture of a +human user using an appropriate input device, Drag and Drop provides both +a mechanism to enable continuous feedback regarding the +possible outcome of any subsequent data transfer to the user during +navigation over the presentation elements in the GUI, and the facilities +to provide for any subsequent data negotiation and transfer. +

+This package defines the classes and interfaces necessary to perform Drag +and Drop operations in Java. It +defines classes for the drag-source and the drop-target, as well as +events for transferring the data being dragged. This package also provides +a means for giving visual feedback to the user throughout the +duration of the Drag and Drop operation. +

+A typical Drag and Drop operation can be decomposed into the following +states (not entirely sequentially): +

+

+ +The gesture itself moves a logical cursor across the GUI hierarchy, +intersecting the geometry of GUI Component(s), possibly resulting in +the logical "Drag" cursor entering, crossing, and subsequently +leaving Component(s) and associated DropTarget(s). +

+The DragSource object manifests "Drag Over" feedback to the user, in the typical case by animating the GUI Cursor associated with the +logical cursor. +

+DropTarget objects manifest "Drag Under" feedback to the user, in +the typical case, by rendering animations into their associated GUI +Component(s) under the GUI Cursor. +

+The determination of the feedback effects, and the ultimate success +or failure of the data transfer, should one occur, is parameterized +as follows: +

+ + + +@since 1.2 + + diff --git a/out/production/classes1/awt/dnd/peer/package.html b/out/production/classes1/awt/dnd/peer/package.html new file mode 100644 index 0000000..6c83292 --- /dev/null +++ b/out/production/classes1/awt/dnd/peer/package.html @@ -0,0 +1,51 @@ + + + + + + +Provides for interfacing with the underlying window system +in order to access its platform-dependent drag-and-drop facilities. +This package is only used by AWT toolkit developers. + + +

Package Specification

+ +##### FILL IN ANY SPECS NEEDED BY JAVA COMPATIBILITY KIT ##### + + +

Related Documentation

+ +For overviews, tutorials, examples, guides, and tool documentation, please see: + + + + + diff --git a/out/production/classes1/awt/doc-files/AWTThreadIssues.html b/out/production/classes1/awt/doc-files/AWTThreadIssues.html new file mode 100644 index 0000000..118e2a6 --- /dev/null +++ b/out/production/classes1/awt/doc-files/AWTThreadIssues.html @@ -0,0 +1,193 @@ + + + + + + + + + +

AWT Threading Issues

+ + +

Listeners and threads

+ +Unless otherwise noted all AWT listeners are notified on the event +dispatch thread. It is safe to remove/add listeners from any thread +during dispatching, but the changes only effect subsequent notification. +
For example, if a key listeners is added from another key listener, the +newly added listener is only notified on subsequent key events. + + +

Auto-shutdown

+ +According to +The Java™ Virtual Machine Specification, +sections 2.17.9 and 2.19, +the Java virtual machine (JVM) initially starts up with a single non-daemon +thread, which typically calls the main method of some class. +The virtual machine terminates all its activity and exits when +one of two things happens: + +

+This implies that if an application doesn't start any threads itself, +the JVM will exit as soon as main terminates. +This is not the case, however, for a simple application +that creates and displays a java.awt.Frame: +

+        public static void main(String[] args) {
+            Frame frame = new Frame();
+            frame.setVisible(true);
+         }
+
+The reason is that AWT encapsulates asynchronous event dispatch +machinery to process events AWT or Swing components can fire. The +exact behavior of this machinery is implementation-dependent. In +particular, it can start non-daemon helper threads for its internal +purposes. In fact, these are the threads that prevent the example +above from exiting. The only restrictions imposed on the behavior of +this machinery are as follows: + +The implications of the third restriction are as follows: + +It depends on the implementation if and when the non-daemon helper +threads are terminated once all components are made undisplayable. +The implementation-specific details are given below. + +

+Implementation-dependent behavior. +

+ +Prior to 1.4, the helper threads were never terminated. +

+Starting with 1.4, the behavior has changed as a result of the fix for + +4030718. With the current implementation, AWT terminates all its +helper threads allowing the application to exit cleanly when the +following three conditions are true: +

+Therefore, a stand-alone AWT application that wishes to exit +cleanly without calling System.exit must: + +Note, that while an application following these recommendations will +exit cleanly under normal conditions, it is not guaranteed that it +will exit cleanly in all cases. Two examples: + +On the other hand, if you require the JVM to continue running even after +the application has made all components undisplayable you should start a +non-daemon thread that blocks forever. + +
+        <...>
+        Runnable r = new Runnable() {
+            public void run() {
+                Object o = new Object();
+                try {
+                    synchronized (o) {
+                        o.wait();
+                    }
+                } catch (InterruptedException ie) {
+                }
+            }
+        };
+        Thread t = new Thread(r);
+        t.setDaemon(false);
+        t.start();
+        <...>
+
+ +The Java™ Virtual Machine Specification + guarantees +that the JVM doesn't exit until this thread terminates. + + diff --git a/out/production/classes1/awt/doc-files/BorderLayout-1.gif b/out/production/classes1/awt/doc-files/BorderLayout-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..8a1a2bb670f2c5443fc1e0f5a1fa505b5ef93927 GIT binary patch literal 2716 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 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/Choice-1.gif b/out/production/classes1/awt/doc-files/Choice-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..140c0f9cd04327677ff0590741d7b76e6b4fed45 GIT binary patch literal 486 zcmVBNk%w1VRisL0HFW?0002Mz`+0i{{R30A^8LW00062EC2ui0CoU900091 zgpaAq?GK}zwAzca-n@GigyKk+=82~2%C_a=#_~+pFKFlbUc>wk432!lqLD^CDwn7v z^Z9g^1k|eaip^@b+^+X4I7vz1viXemigBp4`wia$)(KS=idP-z2siUG1 zQkzP)dPDd+ms_lPOswo!X3*xU$JSnTcS^dK6ejBzFtuEFtqG z-W<7*-!dq(}yw5rmpJhD!G36*OQuP)1l6^nH$&#h=}ko9x6t&X=G<&IVR%b$P` zeEZTv=5&hR!G2rXA&l6AVY^ptF^-h?aU#c(TScx6h%#nVmp6av?3wf5(3wG#mOA?M c=hUi22X5^;vFzEjYumn!JGbuLx(fgRJCauNM*si- literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/DesktopProperties.html b/out/production/classes1/awt/doc-files/DesktopProperties.html new file mode 100644 index 0000000..0153a07 --- /dev/null +++ b/out/production/classes1/awt/doc-files/DesktopProperties.html @@ -0,0 +1,277 @@ + + + + + + + + + +

AWT Desktop Properties

+ +The following refers to standard AWT desktop properties that +may be obtained via the + +Toolkit.getDesktopProperty method. +

+Each desktop property is named by a unique string, which +is the "name" of that property. +

+Desktop properties supported by the AWT but not documented +elsewhere - typically because there is no suitable +method or class - are documented here. +

+Desktop properties documented elsewhere are those which are +tightly coupled with a method or class which documents them. +

+Since desktop properties abstract an underlying platform +setting, they may not be available in environments that do +not support them. In the event that a desktop property is +unavailable for any reason, the implementation will return +null. +

+The following table summarizes the desktop properties documented +here, and their value types. +

+ + + + + + + + + + + + + + + + +
Property NameValue TypeSummary Description
awt.font.desktophintsjava.util.MapFont smoothing (text antialiasing) settings.
sun.awt.enableExtraMouseButtonsjava.lang.BooleanControls if mouse events from extra buttons are to be generated or not
+ +

Desktop Font Rendering Hints

+Desktop Property: "awt.font.desktophints" +

+Modern desktops support various forms of text antialiasing (font smoothing). +

+These are applied by platform-specific heavyweight components. +However an application may want to render text using the same text +antialiasing on a drawing surface or lightweight (non-platform) component using + Graphics2D methods. +This is particularly important when creating + Swing components which +are required to appear consistent with native desktop components or other +Swing components. + +

Basic Usage

+The standard desktop property named +"awt.font.desktophints" +can be used to obtain the rendering hints that best match the desktop settings. + +The return value is a + Map of + RenderingHints which +can be directly applied to a Graphics2D. +

+It is a Map as more than one hint may be needed. +If non-null this can be directly applied to the Graphics2D. +


+Toolkit tk = Toolkit.getDefaultToolkit();
+Map map = (Map)(tk.getDesktopProperty("awt.font.desktophints"));
+if (map != null) {
+    graphics2D.addRenderingHints(map);
+}
+
+

Advanced Usage Tips

+ +

Listening for changes

+

+An application can listen for changes in the property +using a +PropertyChangeListener : +


+tk.addPropertyChangeListener("awt.font.desktophints", pcl); 
+
+Listening for changes is recommended as users can, on rare occasions, +reconfigure a desktop environment whilst applications are running +in a way that may affect the selection of these hints, and furthermore +many desktop environments support dynamic reconfiguration of these +running applications to conform to the new settings. +

+There is no direct way to discover if dynamic reconfiguration +is expected of running applications but the default assumption +should be that it is expected, since most modern desktop environments +do provide this capability. +

Text Measurement

+

+Text always needs to be measured using the same + FontRenderContext +as used for rendering. The text anti-aliasing hint is a component of +the FontRenderContext. +A FontMetrics +obtained from the Graphics object on which the hint +has been set will measure text appropriately. +This is not a unique requirement for clients that specify this hint +directly, since the value of the FontRenderContext should +never be assumed, so is discussed here principally as a reminder. +

Saving and restoring Graphics State

+

+Sometimes an application may need to apply these hints on a shared +Graphics only temporarily, restoring the previous values after they +have been applied to text rendering operations. +The following sample code shows one way to do this. +


+/**
+  * Get rendering hints from a Graphics instance.
+  * "hintsToSave" is a Map of RenderingHint key-values.
+  * For each hint key present in that map, the value of that
+  * hint is obtained from the Graphics and stored as the value
+  * for the key in savedHints.
+  */
+RenderingHints getRenderingHints(Graphics2D g2d,
+                                  RenderingHints hintsToSave,
+                                  RenderingHints savedHints) {
+     if (savedHints == null) {
+         savedHints = new RenderingHints(null);
+     } else {
+         savedHints.clear();
+     }
+     if (hintsToSave.size() == 0) {
+         return savedHints;
+     }
+     /* RenderingHints.keySet() returns Set<Object> */
+     for (Object o : hintsToSave.keySet()) {
+         RenderingHints.Key key = (RenderingHints.Key)o;
+         Object value = g2d.getRenderingHint(key);
+         savedHints.put(key, value);
+     }
+     return savedHints;
+}
+
+
+Toolkit tk = Toolkit.getDefaultToolkit();
+Map map = (Map)(tk.getDesktopProperty("awt.font.desktophints"));
+Map oldHints;
+if (map != null) {
+     oldHints = getRenderingHints(graphic2D, map, null);
+     graphics2D.addRenderingHints(map);
+     ..
+     graphics2D.addRenderingHints(oldHints);
+}
+
+ +

Details

+
    +
  • The return value will always be null or a Map +

    +
  • If the return value is null, then no desktop properties are available, +and dynamic updates will not be available. This is a typical behaviour if +the JDK does not recognise the desktop environment, or it is one which +has no such settings. The Headless toolkit is one such example. +Therefore it is important to test against null before using the map. +

    +
  • If non-null the value will be a Map of +RenderingHints such that every key is an instance of +RenderingHints.Key and the value is a legal value for that key. +

    +
  • The map may contain the default value for a hint. This is +needed in the event there is a previously a non-default value for the hint +set on the Graphics2D. If the map did not contain +the default value, then addRenderingHints(Map) would leave +the previous hint which may not correspond to the desktop setting. +

    +An application can use setRenderingHints(Map) to reinitialise +all hints, but this would affect unrelated hints too. +

    +

  • A multi-screen desktop may support per-screen device settings in which +case the returned value is for the default screen of the desktop. +An application may want to use the settings for the screen on +which they will be applied. +The per-screen device hints may be obtained by per-device property names +which are constructed as the String concatenation +
    
+"awt.font.desktophints" + "." + GraphicsDevice.getIDstring();
+
    +

    +An application can also listen for changes on these properties. +

    +However this is an extremely unlikely configuration, so to help +ease of development, if only a single, desktop-wide setting is supported, +then querying each of these per-device settings will return null. +So to determine if there are per-device settings it is sufficient to +determine that there is a non-null return for any screen device using +the per-device property name. +

+

Mouse Functionality

+Desktop Property: "sun.awt.enableExtraMouseButtons" +

+This property determines if events from extra mouse buttons (if they are exist and are +enabled by the underlying operating system) are allowed to be processed and posted into +{@code EventQueue}. +
+The value could be changed by passing "sun.awt.enableExtraMouseButtons" +property value into java before application starts. This could be done with the following command: +

+java -Dsun.awt.enableExtraMouseButtons=false Application
+
+Once set on application startup, it is impossible to change this value after. +
+Current value could also be queried using getDesktopProperty("sun.awt.enableExtraMouseButtons") +method. +
+If the property is set to {@code true} then +
    +
  • it is still legal to create {@code MouseEvent} objects with +standard buttons and, if the mouse has more +then three buttons, it is also legal to use buttons from the range started +from 0 up to {@link java.awt.MouseInfo#getNumberOfButtons() getNumberOfButtons()}. + +
  • it is legal to use standard button masks when using {@code Robot.mousePress()} +and {@code Robot.mouseRelease()} methods and, if the mouse has more then three buttons, +it is also legal to use masks for existing extended mouse buttons. +That way, if there are more then three buttons on the mouse then it is allowed to +use button masks corresponding to the buttons +in the range from 1 up to {@link java.awt.MouseInfo#getNumberOfButtons() getNumberOfButtons()} +
+
+If the property is set to {@code false} then +
    +
  • it is legal to create {@code MouseEvent} objects with standard buttons +only: {@code NOBUTTON}, {@code BUTTON1}, {@code BUTTON2} and +{@code BUTTON3} +
  • it is legal to use standard button masks only: +{@code InputEvent.BUTTON1_DOWN_MASK}, {@code InputEvent.BUTTON2_DOWN_MASK}, +{@code InputEvent.BUTTON3_DOWN_MASK} +
+ +This property should be used when there is no need in listening mouse events fired as a result of +activity with extra mouse button. +By default this property is set to {@code true}. + + diff --git a/out/production/classes1/awt/doc-files/FlowLayout-1.gif b/out/production/classes1/awt/doc-files/FlowLayout-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..5f82d060fe9d60baa757ec1ad6f28b31e4548481 GIT binary patch literal 1918 zcmV-^2Z8uUNk%w1VYdP90HFW?0002Mz`+0i{{R30A^8LW00062EC2ui0Jj0|00091 zgpaAq?GK}zwAzca-n{z{hT=$;=82~2%C_zc$MQ_qb}Z!j&iDQg3<`(DqVb4KDwoWr z^9hYgr_lxVip^@b+^+Wv4kxXGfccD0tJmzd`wfrF=k&V$j?e4&{J#GWsMnAaSZH{N zn5ekO*y#8uH&_NqS!sERnW?!c$Uw*m8Y((UT3RY;nyR|W+Um-N`YJn1TWbp#d#k(4 z+dG@<8!S9b{0Ll(oUFVY={d;^9W7maJZ*iA&03w!-R*6;{VhID{ulmcuy;_--tK$u zmfi{AUT^>FY)2okpC=#J@1DScjo_*I$FI|zfCL*l#FcMhK!$Y?qI-xjqq_cx&Cu*q za0aADiU>j`(18R9VR7O6z0>WFKNQ63fAh*l|T6{HCqyE&wgyfx^;II>QkvwyQ*!w^{w7- zaqTvxm{%#xbxQXd<~#Nd;HifjBTcODtK-R!$@E#gn6hSpeK&jF+xfF-u%Snr&RP1j zYLuy0yB2Htwd|^`XWMR9`?hXzxp(`{*88_`X~BmZS0?F(^5x8%JAV!xfPm=Kt6RU0 zJv)Nw+Pi!I4nDkxc&z9W-WvRdxswnJbM*=SF$5#wLhi{-af3 zBiY#oTP`uSqEE1xIpi9c4SJA8YIe1!Mp0@sWu#nfm6?{3nN=1^k_rmx8fQKlRiuO6 z>DHwgWm*Au4myz zten1nYG|raJ;`iJ$3B#-pny)=EQ!y`1+27bF~uvPnqsT&pxlz{ZJ#b;De7PG^hzt7 zoKhPUsgzpVFTBH+OK-Wf*^A_#0JCeWyN;rpt-ueLYVJi7|LZTPbGFK`ly1i8RbkG4 zESRdnGNx_Dcdo2(%xJX>@>x`ci}9vKdb+5n5>BgZ&S;Fh?o5OEOf!NZW9p`!1aDdA z(C&$@J&)9M6uULQL~{Mmw+`X#2hUp@Vm6Ib8*4SPSo`C(+7jcqHb!DMMD}HI zYmzqKb%)(HxNqapcb0q0UGus(53bnZK{}pEw|v_Ee3T9<6zCl0&m}JT)!d<=Idh>m z$NArQe-65-o2w38>0tK0Ac^z4K0{`=g=FF*G5 z*H8WZ_(QM%{>=C9KjZ;0fW#Xh0fA@01M)6`3d9`)8%VncLJ)QmoFIQHXhHm7FoX2j zAP3>&!4I-0gd#)_2}?+x6Qa;KDqNv(TIfRGz%YionIR2rW5XNDCWkt74G(*$njZqu zG(sGrXo_e=&mb|0npq+fC*#B?HYSQvGz|U~tEiVNV$pS5ES?s-xUlVkv36e^qmkBU z#uTD4jVxRv8(-+gH_9-Ma;za8>xjcU;&F$1+@lZs=*J)eGLS?ZBq5Jz$U`bIk&0|0 zBO3|DM?!LnlANR!D{09rVltClB%sjFO+i>BPn-N##4?Xm8wLHDO))kR>D#~ zpqypBUTMqK$TFAK*d;HCQ_Eih4wu42Br%J*$YUbYk;+_VB%A3>Nxy5i*us$7V2DQE!yc$d}K48mGLG$Nkh(iVgsJ~)J8u0 zX`g=rG#dOIsOGrb1%vEV{Ms>6!HlhBeJo@1x~#%Z_FbRl>|j|2R-1@qLj3iqptN*T0dR@PVHMipbbo7Hclv@_ZM)^{O`?sSn;-QG&~x;@<~cj-3L z?>5xC;*A`6%PZ2MqL-lOT`x+-1K;?{cfRzkuYK=}-~8%#zx?g5fBy^M01J4)DJTE{ EJ7XHfG5`Po literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/FocusCycle.gif b/out/production/classes1/awt/doc-files/FocusCycle.gif new file mode 100644 index 0000000000000000000000000000000000000000..4777e217368b543b9594ef239dc441a48ce33f18 GIT binary patch literal 6933 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 buy-L$VU + + + + + + The AWT Focus Subsystem + + + +

The AWT Focus Subsystem

+ +

+ Prior to Java 2 Standard Edition, JDK 1.4, the AWT focus subsystem + was inadequate. It suffered from major design and API problems, + as well as over a hundred open bugs. Many of these bugs were caused by + platform inconsistencies, or incompatibilities between the native + focus system for heavyweights and the Java focus system for + lightweights. +

+ The single worst problem with the AWT focus implementation was the + inability to query for the currently focused Component. Not only was + there no API for such a query, but also, because of an insufficient + architecture, such information was not even maintained by the code. +

+ Almost as bad was the inability of lightweight children of a Window + (not a Frame or a Dialog) to receive keyboard input. This problem + existed because Windows never received WINDOW_ACTIVATED + events and thus could never be activated, and only active Windows + could contain focused Components. +

+ In addition, many developers noted that the APIs for FocusEvent and + WindowEvent were insufficient because they did not provide a way for + determining the "opposite" Component involved in the focus or + activation change. For example, when a Component received a FOCUS_LOST + event, it had no way of knowing which Component was gaining + focus. Since Microsoft Windows provides this functionality for free, + developers migrating from Microsoft Windows C/C++ or Visual Basic to + Java had been frustrated by the omission. +

+ To address these and other deficiencies, we have designed a new focus + model for the AWT in JDK 1.4. The primary design changes were the + construction of a new centralized KeyboardFocusManager class, and a + lightweight focus architecture. The amount of focus-related, + platform-dependent code has been minimized and replaced by fully + pluggable and extensible public APIs in the AWT. While we have + attempted to remain backward compatible with the existing + implementation, we were forced to make minor incompatible changes in + order to reach an elegant and workable conclusion. We anticipate that + these incompatibilities will have only a trivial impact on existing + applications. +

+ This document is a formal specification both of the new APIs and of + existing APIs which remain relevant in the new model. Combined with + the javadoc for focus-related classes and methods, this document + should enable developers to create substantial AWT and Swing + applications with a focus behavior that is customized yet consistent + across platforms. This document has the following sections: +

+ + +

Overview of KeyboardFocusManager

+

+ The focus model is centralized around a single class, + KeyboardFocusManager, that provides a set of APIs for client code to + inquire about the current focus state, initiate focus changes, and + replace default focus event dispatching with a custom dispatcher. + Clients can inquire about the focus state directly, or can register a + PropertyChangeListener that will receive PropertyChangeEvents when a + change to the focus state occurs. +

+ KeyboardFocusManager introduces the following main concepts and their + terminology: +

    +
  1. The "focus owner" -- the Component which typically receives + keyboard input. +
  2. The "permanent focus owner" -- the last Component to receive + focus permanently. The "focus owner" and the "permanent focus + owner" are equivalent unless a temporary focus change is + currently in effect. In such a situation, the "permanent focus + owner" will again be the "focus owner" when the temporary focus + change ends. +
  3. The "focused Window" -- the Window which contains the "focus + owner". +
  4. The "active Window" -- the Frame or Dialog that is either the + "focused Window", or the first Frame or Dialog that is an owner + of the "focused Window". +
  5. "Focus traversal" -- the user's ability to change the "focus + owner" without moving the cursor. Typically, this is done using + the keyboard (for example, by using the TAB key), or an + equivalent device in an accessible environment. Client code can + also initiate traversal programmatically. Normal focus traversal + can be either "forward" to the "next" Component, or "backward" to + the "previous" Component. +
  6. "Focus traversal cycle" -- a portion of the Component hierarchy, + such that normal focus traversal "forward" (or "backward") will + traverse through all of the Components in the focus cycle, but no + other Components. This cycle provides a mapping from an arbitrary + Component in the cycle to its "next" (forward traversal) and + "previous" (backward traversal) Components. +
  7. "Traversable Component" -- Component that is in the focus traversal + cycle. +
  8. "Non-traversable Component" -- Component that is not in the focus + traversal cycle. Note that a non-traversable Component can nevertheless + be focused in other way (e.g. by direct focus request). +
  9. "Focus cycle root" -- Container that is the root of the Component + hierarchy for a particular "focus traversal cycle". When the + "focus owner" is a Component inside a particular cycle, normal + forward and backward focus traversal cannot move the "focus + owner" above the focus cycle root in the Component hierarchy. + Instead, two additional traversal operations, "up cycle" and + "down cycle", are defined to allow keyboard and programmatic + navigation up and down the focus traversal cycle hierarchy.
    10. +
  10. "Focus traversal policy provider" - Container which has + "FocusTraversalPolicyProvider" property as true. This Container will + be used to acquire focus traversal policy. This container doesn't + define new focus cycle but only modifies the order by which its + children are traversed "forward" and "backward". Focus traversal + policy provider can be set using + setFocusTraversalPolicyProvider on the Container. +
+ +

+ Every Window and JInternalFrame is, by default, a "focus cycle + root". If it's the only focus cycle root, then all of its + focusable descendants should be in its focus cycle, and its focus + traversal policy should enforce that they are by making sure that + all will be reached during normal forward (or backward) + traversal. If, on the other hand, the Window or JInternalFrame + has descendants that are also focus cycle roots, then each such + descendant is a member of two focus cycles: the one that it is + the root of, and the one of its nearest focus-cycle-root + ancestor. In order to traverse the focusable components belonging + to the focus cycle of such a "descendant" focus cycle root, one + first traverses (forward or backward) to reach the descendant, + and then uses the "down cycle" operation to reach, in turn, its + descendants. + +

+ Here is an example:
Three groups as described below: ABCF BDE and DGH.
+ +

Assume the following: +

    +
  • A is a Window, which means that it + must be a focus cycle root. +
  • B and D are Containers that + are focus cycle roots. +
  • C is a Container that is not a focus cycle root. +
  • G, H, E, and F are all + Components. +
+ + There are a total of three focus cycle roots in this example: + +
    +
  1. A is a root, and A, B, C, + and F are members of A's cycle. +
  2. B is a root, and B, D, and + E are members of B's cycle. +
  3. D is a root, and D, G, + and H are members of D's cycle. +
+ + Windows are the only Containers which, by default, are focus cycle + roots. + + +KeyboardFocusManager is an abstract class. AWT provides a default +implementation in the DefaultKeyboardFocusManager class. + + + +

KeyboardFocusManager and Browser Contexts

+

+Some browsers partition applets in different code bases into separate +contexts, and establish walls between these contexts. Each thread and +each Component is associated with a particular context and cannot +interfere with threads or access Components in other contexts. In such +a scenario, there will be one KeyboardFocusManager per context. Other +browsers place all applets into the same context, implying that there +will be only a single, global KeyboardFocusManager for all +applets. This behavior is implementation-dependent. Consult your +browser's documentation for more information. No matter how many +contexts there may be, however, there can never be more than one focus +owner, focused Window, or active Window, per ClassLoader. + + + +

KeyEventDispatcher and KeyEventPostProcessor

+

+While the user's KeyEvents should generally be delivered to the focus +owner, there are rare cases where this is not desirable. An input +method is an example of a specialized Component that should receive +KeyEvents even though its associated text Component is and should +remain the focus owner. +

+A KeyEventDispatcher is a lightweight interface that allows client +code to pre-listen to all KeyEvents in a particular context. Instances +of classes that implement the interface and are registered with the +current KeyboardFocusManager will receive KeyEvents before they are +dispatched to the focus owner, allowing the KeyEventDispatcher to +retarget the event, consume it, dispatch it itself, or make other +changes. +

+For consistency, KeyboardFocusManager itself is a +KeyEventDispatcher. By default, the current KeyboardFocusManager will +be the sink for all KeyEvents not dispatched by the registered +KeyEventDispatchers. The current KeyboardFocusManager cannot be +completely deregistered as a KeyEventDispatcher. However, if a +KeyEventDispatcher reports that it dispatched the KeyEvent, regardless +of whether it actually did so, the KeyboardFocusManager will take no +further action with regard to the KeyEvent. (While it is possible for +client code to register the current KeyboardFocusManager as a +KeyEventDispatcher one or more times, there is no obvious reason why +this would be necessary, and therefore it is not recommended.) +

+Client-code may also post-listen to KeyEvents in a particular context +using the KeyEventPostProcessor interface. KeyEventPostProcessors +registered with the current KeyboardFocusManager will receive +KeyEvents after the KeyEvents have been dispatched to and handled by +the focus owner. The KeyEventPostProcessors will also receive +KeyEvents that would have been otherwise discarded because no +Component in the application currently owns the focus. This will allow +applications to implement features that require global KeyEvent post- +handling, such as menu shortcuts. +

+Like KeyEventDispatcher, KeyboardFocusManager also implements +KeyEventPostProcessor, and similar restrictions apply to its use in +that capacity. + + +

FocusEvent and WindowEvent

+

+The AWT defines the following six event types central to the focus +model in two different java.awt.event classes: +

    +
  1. WindowEvent.WINDOW_ACTIVATED: This event is + dispatched to a Frame or Dialog (but never a Window which + is not a Frame or Dialog) when it becomes the active Window. +
  2. WindowEvent.WINDOW_GAINED_FOCUS: This event is + dispatched to a Window when it becomes the focused Window. + Only focusable Windows can receive this event. +
  3. FocusEvent.FOCUS_GAINED: This event is dispatched + to a Component when it becomes the focus owner. Only focusable + Components can receive this event. +
  4. FocusEvent.FOCUS_LOST: This event is dispatched + to a Component when it is no longer the focus owner. +
  5. WindowEvent.WINDOW_LOST_FOCUS: This event is + dispatched to a Window when it is no longer the focused Window. +
  6. WindowEvent.WINDOW_DEACTIVATED: This event is + dispatched to a Frame or Dialog (but never a Window which is + not a Frame or Dialog) when it is no longer the active Window. +
+ + +

Event Delivery

+

+If the focus is not in java application and the user clicks on a focusable +child Componenta of an inactive Frame b, the following events +will be dispatched and handled in order: + +

    +
  1. b will receive a WINDOW_ACTIVATED event. +
  2. Next, b will receive a WINDOW_GAINED_FOCUS event. +
  3. Finally, a will receive a FOCUS_GAINED event. +
+ +If the user later clicks on a focusable child Component c of another +Frame d, the following events will be dispatched and handled in +order: +
    +
  1. a will receive a FOCUS_LOST event. +
  2. b will receive a WINDOW_LOST_FOCUS event. +
  3. b will receive a WINDOW_DEACTIVATED event. +
  4. d will receive a WINDOW_ACTIVATED event. +
  5. d will receive a WINDOW_GAINED_FOCUS event. +
  6. c will receive a FOCUS_GAINED event. +
+ +Note that each event will be fully handled before the next event is +dispatched. This restriction will be enforced even if the Components +are in different contexts and are handled on different event +dispatching threads. +

+In addition, each event type will be dispatched in 1-to-1 +correspondence with its opposite event type. For example, if a +Component receives a FOCUS_GAINED event, under no +circumstances can it ever receive another FOCUS_GAINED +event without an intervening FOCUS_LOST event. +

+Finally, it is important to note that these events are delivered for +informational purposes only. It is impossible, for example, to prevent +the delivery of a pending FOCUS_GAINED event by requesting +focus back to the Component losing focus while handling the preceding +FOCUS_LOST event. While client code may make such a request, +the pending FOCUS_GAINED will still be delivered, +followed later by the events transferring focus back to the original +focus owner. +

+If it is absolutely necessary to suppress the FOCUS_GAINED event, +client code can install a VetoableChangeListener which +rejects the focus change. See Focus +and VetoableChangeListener. + + + +

Opposite Components and Windows

+

+Each event includes information about the "opposite" Component or +Window involved in the focus or activation change. For example, for a +FOCUS_GAINED event, the opposite Component is the Component +that lost focus. If the focus or activation change occurs with a native +application, with a Java application in a different VM or context, or +with no other Component, then the opposite Component or Window is +null. This information is accessible using +FocusEvent.getOppositeComponent or +WindowEvent.getOppositeWindow. +

+On some platforms, it is not possible to discern the opposite +Component or Window when the focus or activation change occurs between +two different heavyweight Components. In these cases, the opposite +Component or Window may be set to null on some platforms, and to a +valid non-null value on other platforms. However, for a focus change +between two lightweight Components which share the same heavyweight +Container, the opposite Component will always be set correctly. Thus, +a pure Swing application can ignore this platform restriction when +using the opposite Component of a focus change that occurred within a +top-level Window. + + +

Temporary FocusEvents

+

+FOCUS_GAINED and FOCUS_LOST events are +marked as either temporary or permanent. +

+Temporary FOCUS_LOST events are sent when a Component is +losing the focus, but will regain the focus shortly. These events +can be useful when focus changes are used as triggers for validation +of data. For instance, a text Component may want to commit its +contents when the user begins interacting with another Component, +and can accomplish this by responding to FOCUS_LOST events. +However, if the FocusEvent received is temporary, +the commit should not be done, since the text field will be receiving +the focus again shortly. +

+A permanent focus transfer typically occurs as the result of a user +clicking on a selectable, heavyweight Component, focus traversal with +the keyboard or an equivalent input device, or from a call to +requestFocus() or requestFocusInWindow(). +

+A temporary focus transfer typically occurs as the result of showing a +Menu or PopupMenu, clicking or dragging a Scrollbar, moving a Window +by dragging the title bar, or making another Window the focused +Window. Note that on some platforms, these actions may not generate +any FocusEvents at all. On others, temporary focus transfers will +occur. +

+When a Component receives a temporary FOCUS_LOST event, +the event's opposite Component (if any) may receive a temporary +FOCUS_GAINED event, but could also receive a permanent +FOCUS_GAINED event. Showing a Menu or PopupMenu, or +clicking or dragging a Scrollbar, should generate a temporary +FOCUS_GAINED event. Changing the focused Window, +however, will yield a permanent FOCUS_GAINED event +for the new focus owner. +

+The Component class includes variants of requestFocus and +requestFocusInWindow which take a desired temporary state as a +parameter. However, because specifying an arbitrary temporary state +may not be implementable on all native windowing systems, correct +behavior for this method can be guaranteed only for lightweight +Components. This method is not intended for general use, but exists +instead as a hook for lightweight Component libraries, such as Swing. + + +

Focus Traversal

+

+Each Component defines its own Set of focus traversal keys for a given +focus traversal operation. Components support separate Sets of keys +for forward and backward traversal, and also for traversal up one +focus traversal cycle. Containers which are focus cycle roots also +support a Set of keys for traversal down one focus traversal cycle. If +a Set is not explicitly defined for a Component, that Component +recursively inherits a Set from its parent, and ultimately from a +context-wide default set on the current KeyboardFocusManager. +

+Using the AWTKeyStroke API, client code can specify +on which of two specific KeyEvents, KEY_PRESSED or +KEY_RELEASED, the focus traversal operation will occur. +Regardless of which KeyEvent is specified, however, all KeyEvents +related to the focus traversal key, including the associated +KEY_TYPED event, will be consumed, and will not be +dispatched to any Component. It is a runtime error to specify a +KEY_TYPED event as mapping to a focus traversal operation, +or to map the same event to multiple focus traversal operations for any +particular Component or for a KeyboardFocusManager's defaults. +

+The default focus traversal keys are implementation-dependent. Sun +recommends that the all implementations for a particular native +platform use the same keys. For Windows and Unix, the recommendations +are: + +

    +
  • traverse forward to the next Component: +
    TextAreas: CTRL-TAB on KEY_PRESSED +
    All others: TAB on KEY_PRESSED and + CTRL-TAB on KEY_PRESSED +
  • traverse backward to the previous Component: +
    TextAreas: CTRL-SHIFT-TAB on + KEY_PRESSED +
    All others: SHIFT-TAB on KEY_PRESSED + and CTRL-SHIFT-TAB on + KEY_PRESSED +
  • traverse up one focus traversal cycle : <none> +
  • traverse down one focus traversal cycle : <none> +
+

+Components can enable and disable all of their focus traversal keys en +masse using Component.setFocusTraversalKeysEnabled. When focus +traversal keys are disabled, the Component receives all KeyEvents for +those keys. When focus traversal keys are enabled, the Component never +receives KeyEvents for traversal keys; instead, the KeyEvents are +automatically mapped to focus traversal operations. +

+For normal forward and backward traversal, the AWT focus +implementation determines which Component to focus next based on the +FocusTraversalPolicy of +the focus owner's focus cycle root or focus traversal policy provider. If the +focus owner is a focus cycle root, then it may be ambiguous as to which +Components represent the next and previous Components to focus during +normal focus traversal. Thus, the current +KeyboardFocusManager maintains a reference to the +"current" focus cycle root, which is global across all contexts. The +current focus cycle root is used to resolve the ambiguity. +

+For up-cycle traversal, the focus owner is set to the current focus +owner's focus cycle root, and the current focus cycle root is set to +the new focus owner's focus cycle root. If, however, the current focus +owner's focus cycle root is a top-level window, then the focus owner +is set to the focus cycle root's default component to focus, and the +current focus cycle root is unchanged. +

+For down-cycle traversal, if the current focus owner is a focus cycle +root, then the focus owner is set to the current focus owner's default +component to focus, and the current focus cycle root is set to the +current focus owner. If the current focus owner is not a focus cycle +root, then no focus traversal operation occurs. + + + +

FocusTraversalPolicy

+

+ +A FocusTraversalPolicy defines the order in which Components within +a particular focus cycle root or focus traversal policy provider are +traversed. Instances of FocusTraversalPolicy can be shared across +Containers, allowing those Containers to implement the same traversal policy. +FocusTraversalPolicies do not need to be reinitialized when the +focus-traversal-cycle hierarchy changes. + +

+Each FocusTraversalPolicy must define the following +five algorithms: + +

    +
  1. Given a focus cycle root and a Component a in that cycle, the + next Component after a. +
  2. Given a focus cycle root and a Component a in that cycle, the + previous Component before a. +
  3. Given a focus cycle root, the "first" Component in that cycle. + The "first" Component is the Component to focus when traversal + wraps in the forward direction. +
  4. Given a focus cycle root, the "last" Component in that cycle. + The "last" Component is the Component to focus when traversal + wraps in the reverse direction. +
  5. Given a focus cycle root, the "default" Component in that cycle. + The "default" Component will be the first to receive focus when + traversing down into a new focus traversal cycle. This may be the + same as the "first" Component, but need not be. +
+ +

+A FocusTraversalPolicy may optionally provide an +algorithm for the following: +

+ Given a Window, the "initial" Component in that Window. The initial + Component will be the first to receive focus when the Window is + first made visible. By default, this is the same as the "default" + Component. +
+ +In addition, Swing provides a subclass of FocusTraversalPolicy, +InternalFrameFocusTraversalPolicy, which allows developers +to provide an algorithm for the following: + +
+ Given a JInternalFrame, the "initial" Component in that + JInternalFrame. The initial Component is the first to + receive focus when the JInternalFrame is first selected. + By default, this is the same as the JInternalFrame's + default Component to focus. +
+ +A FocusTraversalPolicy is installed on a Container using +Container.setFocusTraversalPolicy. If a policy is not explicitly +set, then a Container inherits its policy from its nearest focus-cycle-root +ancestor. Top-levels initialize their focus traversal policies using the context +default policy. The context default policy is established by using +KeyboardFocusManager. setDefaultFocusTraversalPolicy. + +

+AWT provides two standard FocusTraversalPolicy +implementations for use by client code. + +

    +
  1. ContainerOrderFocusTraversalPolicy: Iterates across the + Components in a focus traversal cycle in the order they were added + to their Containers. Each Component is tested for fitness using the + accept(Component) method. By default, a Component is fit only if it + is visible, displayable, enabled, and focusable. +
  2. By default, ContainerOrderFocusTraversalPolicy implicitly transfers + focus down-cycle. That is, during normal forward focus traversal, + the Component traversed after a focus cycle root will be the + focus-cycle-root's default Component to focus, regardless of whether + the focus cycle root is a traversable or non-traversable Container + (see the pic.1,2 below). Such behavior provides backward compatibility + with applications designed without the concepts of up- and down-cycle + traversal. +
  3. DefaultFocusTraversalPolicy: A subclass of + ContainerOrderFocusTraversalPolicy which redefines + the fitness test. If client code has explicitly set the + focusability of a Component by either overriding + Component.isFocusTraversable() or + Component.isFocusable(), or by calling + Component.setFocusable(boolean), then a + DefaultFocusTraversalPolicy behaves exactly + like a ContainerOrderFocusTraversalPolicy. If, + however, the Component is relying on default focusability, then a + DefaultFocusTraversalPolicy will reject all + Components with non-focusable peers. +
    + The focusability of a peer is implementation-dependent. Sun + recommends that all implementations for a particular native platform + construct peers with the same focusability. The recommendations for + Windows and Unix are that Canvases, Labels, Panels, Scrollbars, + ScrollPanes, Windows, and lightweight Components have non-focusable + peers, and all other Components have focusable peers. These + recommendations are used in the Sun AWT implementations. Note that + the focusability of a Component's peer is different from, and does + not impact, the focusability of the Component itself. +
+

+Swing provides two additional, standard FocusTraversalPolicy +implementations for use by client code. Each implementation is an +InternalFrameFocusTraversalPolicy. + +

    +
  1. SortingFocusTraversalPolicy: Determines traversal order by + sorting the Components of a focus traversal cycle based on a given + Comparator. Each Component is tested for fitness using the + accept(Component) method. By default, a Component is fit only if it + is visible, displayable, enabled, and focusable. +
  2. By default, SortingFocusTraversalPolicy implicitly transfers focus + down-cycle. That is, during normal forward focus traversal, the + Component traversed after a focus cycle root will be the + focus-cycle-root's default Component to focus, regardless of + whether the focus cycle root is a traversable or non-traversable + Container (see the pic.1,2 below). Such behavior provides backward + compatibility with applications designed without the concepts of + up- and down-cycle traversal. +
  3. LayoutFocusTraversalPolicy: A subclass of + SortingFocusTraversalPolicy which sorts Components based on their + size, position, and orientation. Based on their size and position, + Components are roughly categorized into rows and columns. For a + Container with horizontal orientation, columns run left-to-right or + right-to-left, and rows run top-to-bottom. For a Container with + vertical orientation, columns run top-to-bottom and rows run + left-to-right or right-to-left. All columns in a row are fully + traversed before proceeding to the next row. +
    + In addition, the fitness test is extended to exclude JComponents + that have or inherit empty InputMaps. +
+

+The figure below shows an implicit focus transfer: +
Implicit focus transfer.
+ +Assume the following: +

    +
  • A, B and C are components in some window (a container) +
  • R is a container in the window and it is a parent of B and C. + Besides, R is a focus cycle root. +
  • B is the default component in the focul traversal cycle of R +
  • R is a traversable Container in the pic.1, and it is a non-traversable + Container in the pic.2. +
  • In such a case a forward traversal will look as follows: +
      +
    • pic.1 : A -> R -> B -> C +
    • pic.2 : A -> B -> C +
    +
+ +

+Swing applications, or mixed Swing/AWT applications, that use one of +the standard look and feels, or any other look and feel derived from +BasicLookAndFeel, will use LayoutFocusTraversalPolicy for all +Containers by default. +

+All other applications, including pure AWT applications, will use +DefaultFocusTraversalPolicy by default. + + +

Focus Traversal Policy Providers

+

+ A Container that isn't a focus cycle root has an option to provide a + FocusTraversalPolicy of its own. To do so, one needs to set Container's focus + traversal policy provider property to true with the call to + +

+ Container.setFocusTraversalPolicyProvider(boolean) +
+ + To determine whether a Container is a focus traversal policy provider, the + following method should be used: + +
+ Container.isFocusTraversalPolicyProvider() +
+ + If focus traversal policy provider property is set on a focus cycle root, it + isn't considered a focus traversal policy provider and behaves just like any + other focus cycle root. + +

+ The main difference between focus cycle roots and focus traversal policy + providers is that the latter allow focus to enter and leave them just as all other + Containers. However, children inside focus traversal policy provider are + traversed in the order determined by provider's FocusTraversalPolicy. In order + to enable focus traversal policy providers to behave this way, + FocusTraversalPolicies treat them in the following manner: + +

    +
  • Focus traversal policy providers can be passed to FocusTraversalPolicy + methods instead of focus cycle roots. +
  • When calculating next or previous Component in + FocusTraversalPolicy.getComponentAfter or + FocusTraversalPolicy.getComponentBefore, +
      +
    • if a Component is a child of a focus traversal policy provider, + the next and previous for this Component are determined using this + focus traversal policy provider's FocusTraversalPolicy. However, + in order for focus to leave the provider, the following rules are + applied: +
        +
      • if at some point the next found Component is + the first Component of focus traversal policy + provider, the Component after the focus traversal policy + provider is returned +
      • if at some point the previous found Component is + the last Component of focus traversal policy + provider, the Component before the focus traversal policy + provider is returned +
      +
    • When calculating the next Component in + FocusTraversalPolicy.getComponentAfter, +
        +
      • if an obtained Component is a non-traversable Container and + it is a focus traversal policy provider, then the default Component + of that provider is returned +
      • if the Component passed to the FocusTraversalPolicy.getComponentAfter + method is a traversable Container and it is a focus + traversal policy provider, then the default Component of this provider + is returned +
      +
    • When calculating the previous Component in + FocusTraversalPolicy.getComponentBefore, +
        +
      • if an obtained Component is a Container (traversable or + non-traversable) and it is a focus traversal policy provider, then + the last Component of that provider is returned +
      +
    +
  • When calculating the first Component in FocusTraversalPolicy.getFirstComponent, +
      +
    • if an obtained Component is a non-traversable Container and it is a focus + traversal policy provider, then the default Component of that provider is + returned +
    • if an obtained Component is a traversable Container and it is a focus traversal + policy provider, then that Container itself is returned +
    +
  • When calculating the last Component in FocusTraversalPolicy.getLastComponent, +
      +
    • if an obtained Component is a Container (traversable or non-traversable) + and it is a focus traversal policy provider, then the last Component of + that provider is returned +
    +
+ + +

Programmatic Traversal

+

+In addition to user-initiated focus traversal, client code can +initiate a focus traversal operation programmatically. To client code, +programmatic traversals are indistinguishable from user-initiated +traversals. The preferred way to initiate a programmatic traversal is +to use one of the following methods on KeyboardFocusManager: + +

    +
  • KeyboardFocusManager.focusNextComponent() +
  • KeyboardFocusManager.focusPreviousComponent() +
  • KeyboardFocusManager.upFocusCycle() +
  • KeyboardFocusManager.downFocusCycle() +
+ +

+Each of these methods initiates the traversal operation with the +current focus owner. If there is currently no focus owner, then no +traversal operation occurs. In addition, if the focus owner is not a +focus cycle root, then downFocusCycle() performs no traversal +operation. +

+KeyboardFocusManager also supports the following variants +of these methods: + +

    +
  • KeyboardFocusManager.focusNextComponent(Component) +
  • KeyboardFocusManager.focusPreviousComponent(Component) +
  • KeyboardFocusManager.upFocusCycle(Component) +
  • KeyboardFocusManager.downFocusCycle(Container) +
+ +Each of these methods initiates the traversal operation with the +specified Component rather than the focus owner. That is, the +traversal occurs as though the specified Component is the focus owner, +though it need not be. +

+Alternate, but equivalent, APIs are defined on the Component and +Container classes themselves: + +

    +
  • Component.transferFocus() +
  • Component.transferFocusBackward() +
  • Component.transferFocusUpCycle() +
  • Container.transferFocusDownCycle() +
+ +As with the KeyboardFocusManager variants, each of these methods +initiates the traversal operation as though the Component is the focus +owner, though it need not be. +

+Also note that hiding or disabling the focus owner, directly or +indirectly via an ancestor, or making the focus owner non-displayable +or non-focusable, initiates an automatic, forward focus traversal. +While hiding any ancestor, lightweight or heavyweight, will always +indirectly hide its children, only disabling a heavyweight ancestor +will disable its children. Thus, disabling a lightweight ancestor of +the focus owner does not automatically initiate a focus traversal. +

+If client code initiates a focus traversal, and there is no other +Component to focus, then the focus owner remains unchanged. If client +code initiates an automatic focus traversal by hiding the focus owner, +directly or indirectly, or by making the focus owner non-displayable or +non-focusable, and there is no other Component to focus, then the +global focus owner is cleared. If client code initiates an automatic +focus traversal by disabling the focus owner, directly or indirectly, +and there is no other Component to focus, then the focus owner remains +unchanged. + + + +

Focusability

+

+A focusable Component can become the focus owner ("focusability") and +participates in keyboard focus traversal ("focus traversability") with +a FocusTraversalPolicy. There is no separation of these two concepts; +a Component must either be both focusable and focus traversable, or +neither. + +A Component expresses this state via the isFocusable() method. By +default, all Components return true from this method. Client code can +change this default by calling Component.setFocusable(boolean). + + + +

Focusable Windows

+

+To support palette windows and input methods, client code can prevent +a Window from becoming the focused Window. By transitivity, this +prevents the Window or any of its descendants from becoming the focus +owner. Non-focusable Windows may still own Windows that are +focusable. By default, every Frame and Dialog is focusable. Every +Window which is not a Frame or Dialog, but whose nearest owning Frame +or Dialog is showing on the screen, and which has at least one +Component in its focus traversal cycle, is also focusable by +default. To make a Window non-focusable, use +Window.setFocusableWindowState(false). +

+If a Window is non-focusable, this restriction is enforced when the +KeyboardFocusManager sees a WINDOW_GAINED_FOCUS +event for the Window. At this point, the focus change is rejected and +focus is reset to a different Window. The rejection recovery scheme +is the same as if a VetoableChangeListener rejected the +focus change. See Focus +and VetoableChangeListener. +

+Because the new focus implementation requires that KeyEvents intended +for a Window or its descendants be proxied through a child of the +Window's owner, and because this proxy must be mapped on X11 in order +to receive events, a Window whose nearest owning Frame or Dialog is +not showing could never receive KeyEvents on X11. To support this +restriction, we have made a distinction between a Window's "window +focusability" and its "window focusability state". A Window's +focusability state is combined with the showing state of the Window's +nearest owning Frame or Dialog to determine the Window's focusability. +By default, all Windows have a focusability state of true. Setting a +Window's focusability state to false ensures that it will not become +the focused Window regardless of the showing state of its nearest +owning Frame or Dialog. +

+Swing allows applications to create JWindows with null owners. Swing +constructs all such JWindows so that they are owned by a private, +hidden Frame. Because the showing state of this Frame will always be +false, a JWindow constructed will a null owner can never be the +focused Window, even if it has a Window focusability state of true. +

+If the focused Window is made non-focusable, then the AWT will attempt +to focus the most recently focused Component of the Window's +owner. The Window's owner will thus become the new focused Window. If +the Window's owner is also a non-focusable Window, then the focus +change request will proceed up the ownership hierarchy recursively. +Since not all platforms support cross-Window focus changes (see +Requesting Focus), it is possible that +all such focus change requests will fail. In this case, the global +focus owner will be cleared and the focused Window will remain unchanged. + + +

Requesting Focus

+ +

+A Component can request that it become the focus owner by calling +Component.requestFocus(). This initiates a permanent +focus transfer to the Component only if the Component is displayable, +focusable, visible and all of its ancestors (with the exception of the +top-level Window) are visible. The request will be immediately denied if +any of these conditions is not met. A disabled Component may be +the focus owner; however, in this case, all KeyEvents will be discarded. +

+The request will also be denied if the Component's top-level Window is +not the focused Window and the platform does not support requesting +focus across Windows. If the request is denied for this reason, the +request is remembered and will be granted when the Window is later +focused by the user. Otherwise, the focus change request changes the +focused Window as well. +

+There is no way to determine synchronously whether a focus change +request has been granted. Instead, client code must install a +FocusListener on the Component and watch for the delivery of a +FOCUS_GAINED event. Client code must not assume that +the Component is the focus owner until it receives this event. +The event may or may not be delivered before requestFocus() +returns. Developers must not assume one behavior or the other. +

+The AWT supports type-ahead if all focus change requests are made on +the EventDispatchThread. If client code requests a focus change, and +the AWT determines that this request might be granted by the native +windowing system, then the AWT will notify the current +KeyboardFocusManager that is should enqueue all KeyEvents with a +timestamp later than the that of the event currently being handled. +These KeyEvents will not be dispatched until the new Component becomes +the focus owner. The AWT will cancel the delayed dispatching request +if the focus change does not succeed at the native level, if the +Component's peer is disposed, or if the focus change is vetoed by a +VetoableChangeListener. KeyboardFocusManagers are not required to +support type-ahead if a focus change request is made from a thread +other than the EventDispatchThread. +

+Because Component.requestFocus() cannot be implemented +consistently across platforms, developers are encouraged to use +Component.requestFocusInWindow() instead. This method +denies cross-Window focus transfers on all platforms automatically. +By eliminating the only platform-specific element of the focus transfer, +this method achieves consistent cross-platform behavior. +

+In addition, requestFocusInWindow() returns a boolean value. +If 'false' is returned, the request is guaranteed to fail. If 'true' is +returned, the request will succeed unless it is vetoed, or an +extraordinary event, such as disposal of the Component's peer, occurs +before the request can be granted by the native windowing +system. Again, while a return value of 'true' indicates that the +request is likely to succeed, developers must never assume that this +Component is the focus owner until this Component receives a +FOCUS_GAINED event. +

+If client code wants no Component in the application to be the focus +owner, it can call the method KeyboardFocusManager. +clearGlobalFocusOwner() on the current +KeyboardFocusManager. If there exists a focus owner +when this method is called, the focus owner will receive a permanent +FOCUS_LOST event. After this point, the AWT +focus implementation will discard all KeyEvents until the user or +client code explicitly sets focus to a Component. +

+The Component class also supports variants of requestFocus and +requestFocusInWindow that allow client code to specify +a temporary state. +See Temporary FocusEvents + + +

Focus and PropertyChangeListener

+

+Client code can listen to changes in context-wide focus state, or to +changes in focus-related state in Components, via +PropertyChangeListeners. +

+The KeyboardFocusManager supports the following properties: + +

    +
  1. focusOwner: the focus owner +
  2. focusedWindow: the focused Window +
  3. activeWindow: the active Window +
  4. defaultFocusTraversalPolicy: the default focus + traversal policy +
  5. forwardDefaultFocusTraversalKeys: the Set of default + FORWARD_TRAVERSAL_KEYS +
  6. backwardDefaultFocusTraversalKeys: the Set of default + BACKWARD_TRAVERSAL_KEYS +
  7. upCycleDefaultFocusTraversalKeys: the Set of default + UP_CYCLE_TRAVERSAL_KEYS +
  8. downCycleDefaultFocusTraversalKeys: the Set of default + DOWN_CYCLE_TRAVERSAL_KEYS +
  9. currentFocusCycleRoot: the current focus cycle root +
+

+A PropertyChangeListener installed on the current +KeyboardFocusManager will only see these changes within +the KeyboardFocusManager's context, even though the +focus owner, focused Window, active Window, and current focus cycle +root comprise the global focus state shared by all contexts. +We believe this is less intrusive than requiring client code to pass +a security check before installing a PropertyChangeListener. +

+Component supports the following focus-related properties: + +

    +
  1. focusable: the Component's focusability +
  2. focusTraversalKeysEnabled: the Component's + focus traversal keys enabled state +
  3. forwardFocusTraversalKeys: the Component's Set of + FORWARD_TRAVERSAL_KEYS +
  4. backwardFocusTraversalKeys: the Component's Set of + BACKWARD_TRAVERSAL_KEYS +
  5. upCycleFocusTraversalKeys: the Component's Set of + UP_CYCLE_TRAVERSAL_KEYS +
+

+In addition to the Component properties, Container supports the +following focus-related properties: + +

    +
  1. downCycleFocusTraversalKeys: the Container's Set of + DOWN_CYCLE_TRAVERSAL_KEYS +
  2. focusTraversalPolicy: the Container's focus + traversal policy +
  3. focusCycleRoot: the Container's focus-cycle-root state +
+

+In addition to the Container properties, Window supports the following +focus-related property: + +

    +
  1. focusableWindow: the Window's focusable Window state +
+

+Also note that a PropertyChangeListener installed on a +Window will never see a PropertyChangeEvent for the +focusCycleRoot property. +A Window is always a focus cycle root; this property cannot change. +

+ +

Focus and VetoableChangeListener

+

+The KeyboardFocusManager also supports +VetoableChangeListeners for the following properties: + +

    +
  1. "focusOwner": the focus owner +
  2. "focusedWindow": the focused Window +
  3. "activeWindow": the active Window +
+ +If a VetoableChangeListener vetoes a focus or activation change by +throwing a PropertyVetoException, the change is aborted. Any +VetoableChangeListeners which had already approved the change will +asynchronously receive PropertyChangeEvents indicating a reversion of +state to the previous value. +

+VetoableChangeListeners are notified of the state change before the +change is reflected in the KeyboardFocusManager. Conversely, +PropertyChangeListeners are notified after the change is reflected. +It follows that all VetoableChangeListeners will be notified before +any PropertyChangeListener. +

+VetoableChangeListeners must be idempotent, and must veto both loss +and gain events for a particular focus change (e.g., both +FOCUS_LOST and FOCUS_GAINED). For example, +if a VetoableChangeListener vetoes a FOCUS_LOST +event, a KeyboardFocusManager is not required to search the +EventQueue and remove the associated pending +FOCUS_GAINED event. Instead, the +KeyboardFocusManager is free to attempt to +dispatch this event and it is the responsibility of the +VetoableChangeListener to veto it as well. In addition, +during processing of the FOCUS_GAINED event, the +KeyboardFocusManager may attempt to resync the global +focus state by synthesizing another FOCUS_LOST event. +This event must be vetoed just as the first FOCUS_LOST event was. +

+A KeyboardFocusManager may not hold any locks while +notifying PropertyChangeListeners of a state change. +This requirement is relaxed for VetoableChangeListeners, +however. Therefore, client-definied VetoableChangeListeners +should avoid acquiring additional locks inside +vetoableChange(PropertyChangeEvent) as this may lead to deadlock. + +If a focus or activation change is rejected, the KeyboardFocusManager +will initiate rejection recovery as follows: + +

    +
  • If a focused or active Window change was rejected, then the + focused or active Window will be reset to the Window which was + previously the focused or active Window. If there is no such + Window, then the KeyboardFocusManager will clear + the global focus owner. +
  • If a focus owner change was rejected, then the focus owner will be + reset to the Component which was previously the focus owner. If + that is not possible, then it will be reset to the next Component + in the focus traversal cycle after the previous focus owner. If + that is also not possible, then the KeyboardFocusManager + will clear the global focus owner. +
+ +VetoableChangeListeners must be careful to avoid vetoing focus +changes initiated as a result of veto rejection recovery. Failure +to anticipate this situation could lead to an infinite cycle of +vetoed focus changes and recovery attempts. + + + +

Z-Order

+

+On some native windowing systems, the Z-order of a Window can affect +its focused or active (if applicable) state. On Microsoft Windows, the +top-most Window is naturally the focused Window as well. However, on +Solaris, many window managers use a point-to-focus model that ignores +Z-order in determining the focused Window. + +When focusing or activating Windows, the AWT adheres to the UI +requirements of the native platform. Therefore, the focus behavior of +Z-order-related methods such as: +

    +
  • Window.toFront() +
  • Window.toBack() +
  • Window.show() +
  • Window.hide() +
  • Window.setVisible(boolean) +
  • Window.dispose() +
  • Frame.setState(int) +
+is platform-dependent. In JDK 1.4, the behavior of these methods on +Microsoft Windows and Solaris is as follows: +
    +
  • Window.toFront():
    + Microsoft Windows: The Window is moved to front, if possible. + While we will always be able to move this Window in front of other + Windows in the same VM, Windows 98 and Windows 2000 do not allow an + application to bring any of its windows to the front unless one + of that application's windows is already in the foreground. In + this case, Windows will instead flash the Window's icon in the + taskbar. If the Window is moved to the front, it will be made + the focused and (if applicable) active Window. +
    + Solaris: The Window is moved to front. In a point-to-focus + window manager, the Window will become the focused Window if it + is the top-most Window underneath the cursor. In a click-to-focus + window manager, the focused Window will remain unchanged. + +
  • Window.toBack():
    + Microsoft Windows: The Window is moved to back. Note however + that Microsoft Windows insists that an owned Window always be in + front of all of its recursive owners. Thus, after the completion of + this operation, the Window may not be the lowest Java Window in the + Z-order. If the Window, or any of its owners, was the focused Window, + then the focused Window is reset to the top-most Window in the VM. +
    + Solaris: The Window is moved to back. Like Microsoft Windows, + some window managers insist than an owned Window always be in front + of all of its recursive owners. Thus, after the completion of this + operation, the Window may not be the lowest Java Window in the + Z-order. If the Window was the focused Window, it will lose + focus in a point-to-focus window manager if it is no longer the + top-most Window under the cursor. In a click-to-focus window + manager, the focused Window will remain unchanged. + +
  • Window.show()/Window.setVisible(true)/Frame.setState(NORMAL):
    + Microsoft Windows: The Window is moved to front and becomes the focused + Window. +
    + Solaris: The Window is moved to front. In a point-to-focus focus + window manager, the Window will be focused if it is now the + top-most Window under the cursor. In a click-to-focus window + manager, the Window will become the focused Window. + +
  • Window.hide()/Window.setVisible(false)/Window.dispose()/ + Frame.setState(ICONIFIED):
    + Microsoft Windows: If the Window was the focused Window, the focused + Window is reset to a window chosen by the OS, or to no window. The + window may be in a native application, or a Java application in + another VM. +
    + Solaris: If the Window was the focused Window, in a point-to- + focus window manager, the top-most Window under the cursor will + become the focused Window. In a click-to-focus window manager, + the focused Window is reset to a window chosen by the window + manager. The window may be in a native application, or a Java + application in another VM. +
+ + +

Replacing DefaultKeyboardFocusManager

+

+KeyboardFocusManagers are pluggable at the browser context +level. Client code can subclass KeyboardFocusManager or +DefaultKeyboardFocusManager to modify the way that WindowEvents +related to focus, FocusEvents, and KeyEvents are handled and +dispatched, and to examine and modify the global focus state. A custom +KeyboardFocusManager can also reject focus changes at a more +fundamental level then a FocusListener or WindowListener ever could. +

+While giving a developer ultimate control over the focus model, +replacing the entire KeyboardFocusManager is a difficult process +requiring a thorough understanding of the peer focus layer. +Fortunately, most applications do not need this much control. +Developers are encouraged to use KeyEventDispatchers, +KeyEventPostProcessors, FocusTraversalPolicies, +VetoableChangeListeners, and other concepts discussed in this document +before resorting to a full replacement of the KeyboardFocusManager. +

+First note that, because unhindered access to Components in other +contexts represents a security hole, the SecurityManager must grant a +new permission, "replaceKeyboardFocusManager", before client code is +permitted to replace the KeyboardFocusManager with an arbitrary +subclass instance. Because of the security check, replacing the +KeyboardFocusManager is not an option for applications that will be +deployed in environments with a SecurityManager, such as applets in a +browser. +

+Once installed, a KeyboardFocusManager instance has +access to the global focus state via a set of protected functions. +The KeyboardFocusManager can only call these functions +if it is installed in the calling thread's context. This ensures +that malicious code cannot circumvent the security check in +KeyboardFocusManager.setCurrentFocusManager. +A KeyboardFocusManager should always work with +the global focus state instead of the context focus state. +Failure to do this will lead to incorrect behavior of the +KeyboardFocusManager. +

+The primary responsibility of a KeyboardFocusManager +is the dispatch of the following events: + +

    +
  • all KeyEvents +
  • all FocusEvents +
  • WindowEvent.WINDOW_GAINED_FOCUS +
  • WindowEvent.WINDOW_LOST_FOCUS +
  • WindowEvent.WINDOW_ACTIVATED +
  • WindowEvent.WINDOW_DEACTIVATED +
+ +The peer layer will provide the KeyboardFocusManager +with all of the above events except WINDOW_ACTIVATED +and WINDOW_DEACTIVATED. The KeyboardFocusManager +must synthesize WINDOW_ACTIVATED and +WINDOW_DEACTIVATED events when appropriate and target them +accordingly. +

+The KeyboardFocusManager may need to retarget the events +provided by the peer layer to its own notion of the focus owner or +focused Window: +

    +
  • A KeyEvent must be retargeted to the focus owner. Because the peer + layer is unaware of any lightweight Components, KeyEvents will + arrive from the peer layer targeted to the focus owner's + heavyweight Container, not the focus owner. +
  • A FOCUS_LOST event must be retargeted to the focus + owner. Again, this is necessary because the peer layer is + unaware of lightweight Components. +
  • A WINDOW_LOST_FOCUS event must be retargeted to + the focused Window. The implementation of the Window class + may cause the native focused Window to differ from the Java + focused Window. +
+

+A KeyboardFocusManager must ensure proper event ordering, +and a 1-to-1 correspondence between an event and its opposite event type. +The peer layer does not make any of these guarantees. For example, it is +possible for the peer layer to send a FOCUS_GAINED +event before a WINDOW_GAINED_FOCUS event. +The KeyboardFocusManager is responsible for +ensuring that the WINDOW_GAINED_FOCUS event is dispatched +before the FOCUS_GAINED event. +

+Before redispatching an event via KeyboardFocusManager. +redispatchEvent, a KeyboardFocusManager +must attempt to update the global focus state. Typically, this +is done using one of the KeyboardFocusManager.setGlobal* +methods; however, an implementation is free to implement its own methods. +After attempting an update, the KeyboardFocusManager +must verify that the global focus state change +was not rejected. A rejection is detected when a call to the +corresponding getGlobal* method returns a value different than the +value just set. Rejections occur in three standard cases: +

    +
  • If the KeyboardFocusManager attempts + to set the global focus owner to a non-focusable Component. +
  • If the KeyboardFocusManager attempts + to set the global focused Window to a non-focusable Window. +
  • If the change is rejected by an installed + VetoableChangeListener. +
+

+Client-defined implementations of KeyboardFocusManager +can adjust the set of focus transfers which are rejected by overriding the +accessor and mutator methods for the global focus state. +

+If a request to change the global focus state is rejected, the +KeyboardFocusManager must discard the event which prompted +the focus change request. The Component to which the event was targeted +must not receive the event. +

+The KeyboardFocusManager is also expected to initiate rejection +recovery as outlined in Focus +and VetoableChangeListener. +

+ Finally, a KeyboardFocusManager must handle the following set of + special cases: +

    +
  • When handling a WINDOW_GAINED_FOCUS event, the + KeyboardFocusManager must set focus to the + appropriate child Component of the Window. If a child + Component of the Window previously requested focus, + but the focus change was rejected because the platform + does not support cross-Window focus change requests, + then focus should be set to that child Component. + Otherwise, if the Window has never been focused, focus should be + set to the Window's initial Component to focus. If the Window was + previously focused, focus should be set to the Window's most + recent focus owner. +
  • The KeyboardFocusManager must ensure that the + opposite Component or Window are as accurate as the native + windowing platform permits. For example, the + KeyboardFocusManager may need to + retarget the opposite Component to a lightweight child of the + heavyweight initially specified by the peer layer. +
    + If the peer layer states that the opposite Component or Window is + null, it is acceptable for the + KeyboardFocusManager to propagate + this value. null indicates that it is highly + probably that no other Component or Window was involved + in the focus or activation change. Because of platform + limitations, this computation may be + subject to a heuristic and could be incorrect. Nevertheless, this + heuristic will be the best possible guess which the peer layer + could make. +
  • Focus and activation changes in which a Component or Window loses + focus or activation to itself must be discarded. +
  • Events posted by the peer layer claiming that the active Window + has lost focus to the focused Window must be discarded. The peer + implementation of the Window class may generate these spurious + events. +
+ + +

Incompatibilities with Previous Releases

+

Cross-platform changes: +

    +
  1. The default focus traversability for all Components is now + 'true'. Previously, some Components (in particular, all + lightweights), had a default focus traversability of 'false'. Note + that despite this change, however, the + DefaultFocusTraversalPolicy for all AWT Containers + will preserve the traversal order of previous releases. +
  2. A request to focus a non-focus traversable (i.e., non-focusable) + Component will be denied. Previously, such requests were granted. +
  3. Window.toFront() and Window.toBack() + now perform no operation if the Window is not visible. + Previously, the behavior was platform-dependent. +
  4. KeyListeners installed on Components + will no longer see KeyEvents that map to focus + traversal operations, and + Component.handleEvent() will no longer be invoked + for such events. Previously, AWT Components saw these events + and had an opportunity to consume them before AWT + initiated focus traversal. Code that requires this + functionality should instead disable focus traversal keys on + its Components and handle focus traversal + itself. Alternately, the code can use an + AWTEventListener or + KeyEventDispatcher to pre-listen to all + KeyEvents. +
+

Changes specific to Microsoft Windows: +

    +
  1. Window.toBack() changes the focused Window to + the top-most Window after the Z-order change. +
  2. requestFocus() now allows cross-Window focus + change requests in all cases. Previously, requests were granted + for heavyweights, but denied for lightweights. +
+ + + diff --git a/out/production/classes1/awt/doc-files/FontMetrics-1.gif b/out/production/classes1/awt/doc-files/FontMetrics-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..ab2b255e375bdd9375ae800524e07115b93de696 GIT binary patch literal 290 zcmV+-0p0#bNk%w1VJrYU0Du4h00030|NkNR1OWg50RSuj0000i06PEx0{KjUsmtwb zfSGj48XK+X_R8ZftKTj{3??7P9yF@VMw`!YV%V*zC*}FIy(;%d=eLKqqPNAjLzrj? zg7~C($QbE30(obd)fN{h*rZh{7J~_>xk+^vxK*ku3E0YMl^DAkS*s}n6e>C-8tbam z3mlwE(h+RKYbqnPV^h2gJxyJ0?II}aX++w%ZDcq1&9a*oJ&rs6BU`ARt`2Ih{rwJK o?@pPCUoH+0&h8D}ng{;kW$U$y4K#WRm2In2&{xB2&~&wc zMhr7o%1v*1U72!A*?v!d$M60A37_Zr8k-ntX`?O*hY0No{fa;!ba!_P{_8)1|33lc zUkChpK}eJ@bX4>_tfGJwC3+g{+*3j6jFr4(nhUEe?24BV@tE$ZEMmX>-GFp{LQ1GN z_3Hi7^Dh20PA1r?BiH2JB_ZL%YAe)p?eha<$OB?B=8J;mwg(ycJEyeQ&>agmM&j#IKS~lPzpSZeys&m9A0>|cM zyNb?^7=XMbLk)-M)(^k41_{3Yu`dI3%u=+VdNKMX$m&dZvf9E(zHSr{wvY1aqMt0b zEmza%8Z&w%n>!N%{Sx0Iu44q#(VCg7PrUu!q9O=0FJ%akwI0_-FG`LHPb=96LSoK;bROe@VDuHgdqi z_(Jfi7m^kp&_BoBT!YOMuVEXelEE8GBFQmO#G$ z>to@kbX@Bxw2U9?Fxg$*Q5K!x=g^_4hin8|=>a-{sZJYgMa7(|{KH2+ZgAAt%A5Tf zV?LW)wH(6cfZpzE^}sC=m71YHPhqx(HEz6`9WjUUw%%DAt89M!tcsds;l0QE8LKeIC zfB=#hWpqkUPdAV*r3cOHIG`bAC$udak)FQDwBoAkz-tlNp_YKw;;%<^DoZ0oeOGQ< zNW8h5An;PAG-Te=jVt*IoFznemy+qNo1?+&ZL0h9>V=EXQdS4ZA*&mGW4|3N2R?ij zOySy+={qUg5)ljE@DSAos;ubuy_5Qb{2#bCrvyJC94o;=1n8xJ?=>|j5G3@9jU0ou zACmhPDQaGDNH$1==Er+3nNV;<5yld8wD#80&N&9{VM&A}D}Xd|_(DXz6#edJm*Kg` z4{LRtS;Iz0c~ituA_koWxR@7Z6c;Sfpndt9Dqj!o#Jfg+6MVrE_T~PZ2XahxeVyyi z?VNs1vTqC5_qz+fJnNs^Q2+kGIAGa~yciT%LPKyg7v+$rs}-TD#bQ>>8y5hmqwIh5 z&0-LYzw!unbd7}}QivOZS!D?AYOD+`*~pOlp~=1}Aq@kFed?1iX}JsR#U-Ah@&X?8 zbl&r~$;q9SDi>{r#*BpIY2?brZ_}p{Rk*BX$*WoQJ%7kmh0W=ZL*9--Q{Mq78{mAy}>)iZH7I`_Ae_&Fypv;Dw{6zr~)mv$$)?MlgEa- z=tCERSoo&Ryl)9~z4{E6WRk^|9ezLk)^3)SUWR$jj5z@Me2*KsfhibPF413)vGxWB zP)4`VJwUNxA5)EIJ&Y2=9PQzRIt=mNC_)+#d=D3rhOxT~U)I?+PI4VhrnxDq58L-E zFO*Y{7hN@d}%WUeXL~s+$~MPxGi+zU|kfRw$N2uVx^djh1avJ4Qq64KiB7 zdf-Iuz`v}cQx!m6?@Jf9sD?*@5dCG-I`BJ&g<+Yb-$Xj9m}6~3Ep>KiuuHU+Vj_8E z4}B-ilU>!dTURq(M0AHcZpx^hzxj8tlFZCj6|Uuy!PmAE zWg{$QrOFe$mEftItTeE?Hr0k{_}v>|>WUBGz5W8J7oR)bm-&$FvqsX2n;~kx`ul}< z`4!LJYf9L(c0b{(Zt@H#INtQNMGNkPzTT&45}u_fgPXqFe@?n>{H?G=uC>9>k74D~ zDb#QU5}os@c1TN|)lWkVj-z0tU92vilQP43batwO4WFe%OyszW%L4rD*QyN48UL!r pXMyi&`k#L_sQfRkv@UWvtU7nm9DS&7t1f7uI)7JhFj7cJ_kST@p}YV9 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/GridBagLayout-2.gif b/out/production/classes1/awt/doc-files/GridBagLayout-2.gif new file mode 100644 index 0000000000000000000000000000000000000000..c947c6c24f8d9d63ed340a2a67d8bb5d0cd2f30f GIT binary patch literal 2592 zcmeH`2R9oE13=@o_Fm6y%^ERUqo_VzR#a_`B0&`qyRF@NpAcfxTD1v@8I5S|(OQv^ zP}-lDh_qh z9*;01`9RmcVv9)y0Lz(6YgOWJzEaBsp3u+U4y_nRg9P^m3SOzct+Xz=m0lPM{D8JZ zakY`c>Zck#dQ*5U!yBdvP@EfUT{wf<5~SrL8mZH0-4?F)nR4~v#f7BDr!HNqPWb-5 zLf<~B3~8MZlf#HVwsL!O2)lF_+33k>P@ffci`V=VPBYCW+infaJV z?bLxzK`6ocK`!+N4C1r=m#MBjM+XP|)+n2vUx&x5CqB?y$5B%85l&5a-g*oQHWL4L((SruVQUyJucxgBOLWDILf?`)l(fB;NREI0hx`Qu`nrL{O

JIbl`0~`3_Q#}uAaJ}-gH6_kM)m{luJAaMW0W@d$3wtxz`7{=# zHq{n#qaFjc=;kVepQH|Jw3wlf%Q{xzoxqo`d}y{$j?DIgdi$B&+mBv-s^9WFqrijj zJ4w{XC-TVrTJAsKDh_!I^G?efk`9J|2Su(*Y8NUvMZ-uKm#*yre)D2yFw21Y&ZzEG zzz)S=xnXBiiLtRWc7uKX@wkZ?ba&iL8MjMep)T)E+L~+peDCNK`18X(815$x5}|R~ z`f`HC-bb(ez`beTY9sp|l~%^yY(Nw5{#@u($vi218K=*j=i6fJFNo~(9xNhtlp>ds zlzV7PDZ&Yh)ojETk1uygR#A3i9THa}@*M^vm&HrSu^!5-jRFr$%~ z_l@AbYk-Hw8NwLNUns{OIDIMQqM9pq;PBcq-6ll$%;mzq z_0opD{G0sOj9Xoc8vQWUZJP(rlE;|G(J=ngUx6bwrzeQXj8o=?*|F2pEX4E#8|cj+ zlH0Kycgp_|d+`bz#Xtz8m7i4xz2$Pr^7n8kV!JG#%^STPFUuo0y*qV1k3}Ginf-!n z9oa6@Gm2CXkmEF`6U61I33;^@yqu_h(n<)58S4N&q`qpO8PN1jmqOEHA5=+E1#Gjp zONNE=uTVv`B9evCKj;dY$A8sA9OvX$*X~{%hilo~6R}V862&V5gYC}8o#QHt?DVi8 zyDcK*=GT&dbEdwJ60TP6hvce$ex{!0EA7}wHLjDL_@0iOn_r!&X7PEy9VD+IlhB5UAuy_6km`rd^p3cI%;fSMenkozFnVMzKjrERH|-b z;D)Z3CZh`RwT+yb@gB=IU-^9Fp3x?pfaT(?QzW9ki~Du$NCu zW;1E#CYg`0Yt=9t?X9Hwd?fXY_B3FeG);}(Yc_D*knJ|a5c$?I z-|yi3oVdp#zCW}wWiZDfHuYmOGkYzb!Wya;{@u=|V1i1ey3*E)k?6^vZNyLw2hn8k zkkCfkus59`A4YRTh&H{O$NIaa3b7 zf`qS)LL_vBst%D1|>WdHjolH!9LU@c(26U5@$$3jn|;52qR&9(62 z3kSa@!EaJDf!V>{RYq_|Zr2w@fBk;zO|_iLG*1O0E6LGq?)gsKH}xk$Bj#8^U*a9Q awoXW~&oxONKj#s;UgsetfR6(JxcUznqnvO6 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/GridBagLayout-baseline.png b/out/production/classes1/awt/doc-files/GridBagLayout-baseline.png new file mode 100644 index 0000000000000000000000000000000000000000..73c329ef9896e967d9b065adc8b95c871aa85bdd GIT binary patch literal 722 zcmeAS@N?(olHy`uVBq!ia0vp^TY=bwgAGWY*veWwy@IJW5dP`Ue&x43*z?q%UB$jZ*^g)K zT3T-J73h>}Se*Ra^VO9N5iJyJ@ee})Pn#aj?hr^RIWWKMIR@(YyWt3*u z`m=BQ-*(S^{abJQybBWZG|W7*UjAdh@Adjy_}t|^zH_6)U*Gyxr!a$e67mXgG0h@UtJ401l*@9gF~S9MlB>r7Ko%ZU-9U@l2A5Xj?>rU?vB4#R7@02Iek@3 z7~#ak-;QZGa)lCZ1G$RdpQZ;m^f>R>e3dq4a%mT-d>!(3GP{wrcDu=b)fHxims-rNu%sa z&!`};3?}QK$y=68xxiAkL@m=(b0Oy&4_>1>Mw3f?%QOuh?*gV(22WQ%mvv4FO#ll@ BPH_ML literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/GridLayout-1.gif b/out/production/classes1/awt/doc-files/GridLayout-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..e48d75f6478d845f48f49f57d73057df0baf5c96 GIT binary patch literal 1764 zcmd^;`#;oa6vsc`kx?qy(lo|(RU{n%mYpt}Yc--W zJ7SixE>YjqMAl}a?V?y@%rHt9i=vv@nb+=rvFEqvoaemH`Fx(&zM~nG0CkIs1Sx~u9KBAU1R=8x*MZsUiWsB_QXzV&P_Z@OzQcG! z!m%GNU04b*L1~!g1ElC2==i9a%@m_S1PDRVS?Kc-3=%9U!O;gCL9svRbD63FTaD?5 zJ{>d%z-=*nc4GB8L*fI+BLY1L9eWz*SUVRqo*DyZ^+3@zx1Q7TfY@z5wE z2taE#26T1Pd}A6kH6V))k_D+B`~Ynrh(N=9 zOSO2In zCg9AuDJM|Am7D_FBr+~ix@JLVq1If80TDq61LQz6v`C2M5Z!^01YHiY;gB&j+i7@# z$X4574t)YfnsxrKVXG0Y`3sn;g!WWpukwqxj!&JlIHk!kY5m^(_;g+R#e_LKI(ie0s`&+p^fb#tjzRd~^Yjl{ zUPWnh(*~b%>`UnLGYso$4Ktm21`XVmuesKybL1DgY$sXmE==jJZmCK(DdB16V^3eaRZw zyBY1Cjqc+^9>2@SZG@CHFWSoQKa01kphTR@D{P2AW?NPhx5Ccjdj7e{fW95ow&jm> z=U(-GyX1~t$UBki>x-|8Y7g!HblY24I`B+TQmGWKUn-`m>i0Dyn$8%i5xJIbyLEi# zb%#49J6|5UeQHVO+eSubqr*)LPoI%1mN#Eo7aPo5Tp?JN(b6wj=@_^7zMIa>1;6d2 z9f)b4Vp2Bx!2gV5^iMxeyRnD7s)(^ik-=qSd3Nau(PF2b^M^aE@5?G$%qwlj8=3Xq zv6sVcR*i_GP6mB<$)TrAaj(9@-L?v(_g4k&h2u8$u&<1uQ= zstak+%~_ibyH>nN%1yW(}~>Ur^FY13aO^gcM2m=G__=t*oW zi83W+1Dz|CtQYp(tGd%|Oy7Ta8TRY9pJbK3Oyy91Pq$LXnV@mmiH;#Zr8c=ym8Hr0 VU54$sYroR9EK8vW>~I5C`~yt@kY4}* literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/GridLayout-2.gif b/out/production/classes1/awt/doc-files/GridLayout-2.gif new file mode 100644 index 0000000000000000000000000000000000000000..24a2999519a740c9195d052416f0f0fcd9f162f2 GIT binary patch literal 1776 zcmd^;`&*1@7{|ZwJ33h%R*dPSNT{^YM0Fu8HesxkL#}d23?f2rD#>(^R9H)AQaX%7 z&30}o-rAj18%DcXJ6lxSG*fBEvXQjR?98?MU+n$c^L+37bKl?lxt=v^Jzd=bGmwt= z&_qI9LW`(HrBY!MFaZc7Umhz;AX$ ztO^7TLJD-K!AuoWVWG~^G>V40L`8#^L2iXUXOIC%?Z7=?s#+0&u7Fg4K5eLY8gTzH zyr#h(fa`NC1PMJ35T_F&`KW2^CPGsMAONXj!}$nP8kCesG6L8j9glDdwN>D$83Qn4 zfw>5oQq)TrKn#bl?9|QU?4(Cg-VTw#uh;U zj6sdtLmksJHkwH=Off_;k%WI&G6l#yhGk%>E3D0#&p3p53(H@pEYAV57gfhKE> zqjL)7a;)yEA3W19N+A0>0O_Q$Xv!7Ccx1Rcu;HEp-D8d{c z;F8oRCs4MPo&@FuQu4^>hS0HLOos@lAPB)`InV|M4Urrb%@ELF$w4UCJbh=7@9od0nw(0JGU1?VcFrEBh0miK+UuCZM}TUoy7oY5?UOt12r4^mj{;OA{` zW+TpGRkHco=01se(s0_+wCZ_3$Hn)|5h?aNI9_uFw6FR2AS<=j*08_dG({i`>Y(~r-G3&g@* zisF*HCmnlerw?R|FuZJ6U7|JfYmUT0+G1r{8MYv6sJC5TE2ua!vU26)Tz#N|#3RPM5kbL~mgVashdO@?@qHMh-yP=rJd|Q<<>pj}6sPPv^sdxA@^E2uyxE^7 z*I$iF@AIW4M|MP<7<}Zf+_u5sbX|Cspfi5ZB<*ibN8yimnOIR3{mZ-My(_Mt8C8x~ zKVH*Ijcd8~o*6Uo%R5PqoimA>ux+!9HBPLxIz=XP1JAO!u6>DcipWct6`q+NpZ4XD z<$1kiVPB+uz2B@A7sp9%p4X>MtaGiq z^yb}g6dw#qaV~b9f9>o#Pkw&PE4{Rg`F2qUQqQ~B+$y~AOm8SPu4U~3eonjIa3Qs| zT~d_(^7e4S4$tg6d}Y#BS(IEbIm$ylBeGt@fcdkEGg@}_}TU92eEcX zbF-Yf9E!%|DZ>r%`B8W3zI){#+z3WuX&^bTCba1#ogKPMpUrvQBvz(`@{LEfENWIV zqmSOO=zdrJ!;Gcoi&|`+P)-kQ{jZfbuX}d5^4qU^N=C)*F;%iB9*mHE9jj+p*kpOl zD}DPj$3?L{$9qjF_vz*vChRtCcGqA2j;Ep*x3eqny}30j=vsBl-Wv{YB&9L>CnRc5Q;VstlrGX2n^`V!Q$u3#TydGG!Kd$ z4uwrIQ9T^!%-5+k45=Or;QHC-9Tvjp(&Y#T-{0WK9x+-}Hm4#)=+xIV59c2+(B0j+Dht^X5#iswZzUbM9u0>< zDB|Gs=FRlq@ABpoD%l(xxHSyY`qjwGz~KrHz2_0rz+l{P*g z0tlx~DRERis6adT5e;`pMg0By?BCzHDG8)ZAo|qW?CN8FN#r>^$=bv$C@_=;Jm|!{x%>1~ zUPQ9s@|0R6rYt}EvAO%*zt=<}abR3bG8~u_43Ae=92O*88a({4)we+#mp~4^mfLNG^9vSxVd359K`(9d?g(uASm=GG}PI}yx;4>^3~JS z;M3LZhBPUM9wn(YBj*PqhB!^CKOw3VA&Eavi7Y9%G$WTQC741|n>8q;KvaelBAFi} zm_a7|sl@!a(d_8Zd^a)lG8}wTH0=4>WK=Zl-oAV)G5n{l#QXJRVljMXT*f;Q((u*U zJQexx&e8DpEC2ui0Js4M0ssjA0M7^(@D~J;-R&2Pjw26IVmIZ%g!5nVC~ts$pQe-@b($sxr2kpgy}Rn_nh|RMAGjU6`JLk#PNxoDV*2y&XO>^M{(Jk1_2cUo`MzO(`-nN$ z97X@_XCOueDm33^16t?Mf(J&3Q*91PXyHc?f@Iu)7bSS1g&ua~TZIp0_@RU*hBP9H z52kqHiyCq$AY(Ar7}Rm4*{I`#VTHIOYd&J-;*X{c$(4~rCaL6-Og7mSlEXP^8I(Or z`52W|TG<$uS!(I!OaxnTh6_7O7d%5OBsR=bUubY3H4I-U&dSeD>+* zpMVA`=%9oaYUrGCx%uXyi~_o6qmV`_>7v!lp&+NXZ^6Q?vR( z3#ORT!dGog%NlsCdE3fIt+8xnD^j=KdP%NwKb;$sxbdlbWV+xwTa&xe!5gQ%Hqk4b zzA0tM?sfd;7BEWN6>R0evmtDf!DsvnaJ*8w#Boctcjbv+&T-}* zQ_gwcH~X~t=%l|?I7_Faj=1L>72dk*sVgTs?Ut8*(CRAPj(g-%gKqQhmFsSk@5Iw> zJVCq@oP6;uO^y8Xf=fqz=PNZI`t^{*ev#6%bFcjJE`=|C+RJM{()8z7pAypSw;wk7 zE5$Fr-6*L){QcPHFZ@RKg)-j{-&v zM231uv|>ccc*G)hafM=Zq8pQk88m89j$FhYc&?DV2rBV;ndxIll87KcO2&>=9Aid| zxJShN&W{eHBX}M;NHwCzkY{`z$!f;PM)Hw%kX$73Jc&Dr5wcB~JftQQiN{F(&XbM= zWl^RGOGKt+ znqS)`>WYaUJ!&(VpOob-t9e05D)XD-jN=e6G|FItQ<>=$iVx8lwr~+{_vx!aOnKGdYGN(bK+0cFx^qB4pW9%S`Es2IxpqzWC zFA3yP&+zi1t^+9|5jxVJ02G@l9Vjzf>YkDY(xJJ;XhqxiuTzq=od%7m7d7Itmy)uS zIZbIs54usBIt{3?Wav(}NzHZs)27uysyw|pRq^$dqcoxAQI|PWavGDX6ZP6KN5{>Y z>NKr99j8^1BGyKpw5)UeV?m?(PQHdTsi+ewPVt)0z3y?aa`lK&;Yv})4)v06b?o)N z>Qr1Ac9LXesad-TRlllrsej!nT0L7Q%aC=KjX1*<$(=2fqewWm}i+qYT&j+V5a z&Fn^e`cu_PmbGbfEjtZc&$U9YoVWFBS7mzI*Ge(6bp!7Fgsa%j9@e6wP3}$O+1waH zmu}K^8+EUGS(9=XD2vUiRtf9f(Sa6i;T78*o$Jcjniso(wQqd!=g-2v5sv*OuYUK- zU)$=Ew#Q9ud;eS8@d}v1t$i+pEmu_%PB^&p-QR`9OVH1)Ew)5M+H_YY^lneR##D>Cey&y>t5L1V6KikJY<+e4%BX6h&f2B8 zCS9HN2e^>-nt;L1ovnY}!(t0=aCl=jft-!LV+)De^MiKur2R##S)0UR^|r2o?QNYH zdM@W?Q@Z1_ZZx&~E$=2%yxTJGZ)sX!++Nzz@=Y{;>zir*PFleKosfF3#o*=|IAIVT zGKCL@;TXF&ZXhltikrpaO~N=?G`=K`i^bzf0y$Vj{v(om#pE&nbGTqoZX=d&#pN)9 zc~)e8BAQ>t=Br9Fc5rSXo>Rr=5dykYgsv@>2ZreTLHbja-Y%m9MpjUdy40sGsGL*% z>R8V@tgNo}u6zCKlj1tq$4>UL^GWPxPrKU5PVlz7{q1m%yWHna_qyBt?s(6;-uKS; zzWe>}fDgRj2T%CI8~*T!PrTw6&-lhW{_&8HyyPcO`N~`V@|e%O<~Psz&U^mzpbx$1 zM^F0Fn_fw^8u#gWrTWzm>te1a%*WQVAZ>H!_OX|Jd3H|_-uox_vM&h3U{5vR52p6G zCw_^HFBs&*-b}4${so1feCSIbFwXb=8n6GC>1hA?JmP-;UuHj_+S6V^;vawdp%eY} zqs#s9kH7rqPyhPc|Ni*Tzy9~n|Ni^`{{R?(0yuyKSbzq2fC!j?3b=p_*nkfBfDjmg z5;%brSb-LJff$&98n}TR*nuASfgl)yA~=F1Sb`>af+(1RD!76y*n%$jf-o3^GB|@Y zSc5irgE*LjI=F*8*n>X!gFqOBLO6s(ScFD+gh-f#O1Oj@(MU`f6R`AzE&)pcB84hJ zg;!vOS12PnqJ<{0A~fQKB>{%vA%-MDhE-^WBY}olsD^9Eg)-uX9zh{2B8L<~g?9Lc zPMC)xv4?!vhkp2nAMqMpD2O7`AaQ7j7(s_&sE8W>u_2AX*kIimRvcQUAY<9255oVJIOXa zi#cjGbeLPhYma#{l&LY72^x)=Yq}9@VzHUVHYKE1mJ{)55LB5yd73RTmvdxkUWt@; z##C8BY9p2stVu?WMmP>fn;$ltxoMkK$wIt|KCd}ygNB-|cAUUjhEOq_6qaUj`5<&w z70wx9Ul^P+hGtI*o3N#wBjaXch@JlbHJ#hJFyPso=c$Kjm}TiHWjfZL*%@co$($^< zWG4YM)%jQwW}jy$p8I)ZZx)+cR-XXMEJHbEQRbe*m7uLzpy1YFEq0Xexntu=p&%BY z3~H7{7NHQDVjClJ`m|hZbwb?9SsvP;L3W`is$V#!q4lLy>ZMy}rd_gyU)_bFzV%+` zrCB995uJ2hI|^jhWn3c~U>#asEy`YpHef`WV8}(I1SV2n8EHd`U{0!}8w#U#6{Js9 zUdY6y-;V&IjUTBs-KXhrH*B# z4Thz-*;$Q+TSaQ5FY2eV6{Sl5mZxPZOmKRpVv1rORj7|jRft+h)>T|03ScfpTpG1% z(Rr2&^;v+*r_NMTeRZj9+NFw$X*^n?-({)OlwDA|r&oGKu?4GlI;eX!TZS51w#uZq z+NxCQsJuEXm1?S|NnXicRuXhEn z#EP)&8moBfuAJJez1gl13tpymt)ta8;`*VphOK29UzIse0u`*=s<7#5sEn$j-C41g zO0w4Zteo?u%o?d-I;y1q>Zj3lulVYsntH1YyR!zXuVW>xl4`SNGphqDu@ft(iR!4) zdZ;javQG=Oy?UgOQ>-AXpeq}*Lrb+$%e7N`t_~}!9ICQg8?HcVrqilj);hK;nxbag zv~c^RDJEZ;`k!-qw_}>Obj!C@Yqb^{w{q*CcpJD(3%LBLwOLBIzG}FKi@0PKpktPy zjhncFTe$;Dq8#M7m>0Td`kk(OpZ=DgFN>h^ zDY>odowzHYsS9VMtGT{=XDTsgx7%jL`?{J#yQNl~Cjpw1g`8BQyrcP_I zd&!p{To-+5mn2-mCVavssFSUs!ac#lr{Tgo0mGpo!&-B{dPl=Jfy0}j!(?N_dB?-^ za=`Ke#56&~k72}c|^}WIVh=>?~(2zG4iMX-pSu>=$t?yHZ?tb1Y>3*pKh1$MML=*yzW7td4ms$n6No z<#-^}XvqBkNXUQ8j^~Ju>j=q@dED)9K$(@YJ zkxa^|Ov#g+$)*gDmfR=#c*&f+%1yV*u3XEXtjdKP%d#Ahc{0ne{K~tG!p3~e$ehf| zyv)qp%+CDG&>YRuJk8Wx&DMO)*qqJUyv^L)&EEXY;2h54JkI1yf^I^X$^3oI?0ln0 zelOX3l4HRe=zZkz&dNt0rI>y7?4zcr&&jua`AmJ_=N_l%&-bhzsA$k!BF`R3&;P8> z2Eot`-7x0|&*c}oJ<=py(k6Y}*y*TU5yZ_)Ogk))+XsWKPG`4Uo&vf0sz@YDZ@BhG{ za7Zi~kI1BQ$!t2G!v+pYty-_xtai)QNg3U+cuX#vuiwRa&2GEj)pQO{uiNiuIeyRY z`;&Tqf`f#3frW^PieZO~j*pN^jggd1vzrn|zaEP%vV@ zc}Bpg(HH)X;~aerdLUfKO=J#^7fpsNiPAwzl>LCLjESkC7nma@5rmmh;kTX&an6ia zGulw1WQ+#2X|E&5o7P;8<5^N3(~nniP6SX9kk6`7et=X;vuMhuIp6(M*|g@(vlq!C ztxC0Q+lEiy-rd?2S_Hec#LkmT_p4j5_twHaJeTgnvQgUx@rPIBU5s1ciBlZbFu%x% z88c4%kF(y>k3}OUjFhQZB9$Qz28@nk-Oh^q?am&k}hn6f8 zzWV9pfn~Oybl=6+o`3ok=pBJNU3b}8-5Dp|c>o=h8-Ai0$jX2cIk?|z2o|MbT%g?( zm3>(?$J$^XRXE&A$sHx4gji7L;dlLo=v+BRF$ld6rFbF z+2odb_W2K7^>Y$tR|buE}Ygo_-o< xsG_n-YN=?-VZ*Adw(9DuDc}I>thCl@>#MTfs_U-2_S%60z6LAou)-z)06SAbtIGfY literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/LinearGradientPaint.png b/out/production/classes1/awt/doc-files/LinearGradientPaint.png new file mode 100644 index 0000000000000000000000000000000000000000..ef83194fe7ab82ae864f78b6694f2c90ae00de07 GIT binary patch literal 3347 zcmZ8kc{rQ-7B;<1M~dEBx?n6tD-Fg@w31O&rNLCj-r7m*OVmy|;% zV@*{t_inqmHQ0*Yj=%hGc>@FC+k7>u;xCxYSvA7k{8;nm%v(7*xdNMF7?z0~!1wg@ zw70jXztoFdWD~V~WZJ(>b_T^MD=YW+_uJxzX?&7}?ixyYa2(8IHJyQKZ_&2{z{3KE zUcI>^@owpoH0{b#a%v!Niv8$~(S{U33GH+NbZ61ksi~>u6DX0Z&elI3Jb36|hzB)I z4^5IzO&*qp^>uV)2HSK=^~zJtk;stHP-fQB%;4aM4>5deuY((>nm?Tr3sOqVmH!HT z^PdjNU-IWB1?9%YhM{is)av!8KAoyUFM`LKfL=-^!*UnUeDEc9_q*O+hxEDxF-VbP z711|d(#PA|avFrI(=Ole^7i&#|N7W#c7NP8B zAIrLA4cy(WW5yCIh?%vYXW$WiRH8doXIVaML z$pVLI>FFhSnd5NqOtn;B4CWP5YfSf%uk?DQm}X0LHO$AlN&n!;Gv=9_<+Uud0wXQ2*L zfv?H9xv8tGW8ckGrv*?m0;*G@epvYgnV8A?g_=I#xUz;_VQZ{>My-sBtc=S|Or#u! zr%(GwY~Gysl)5yK7B-mid@%F*K&sAQy3Rmyr(>FpQ-+OWN|saRF{kunj>)XNELLtB zIydF6kXJxncl6`j)YEzCr*o4#ti8Na>ZQ_5q%)YF5z8(Sja6qxiLrz=(`x4 zOLS!@xOy_ApjpeS6tZ(1rU{p1Fg_W5sJ(-rfn{7|Jo3-+2hsAuI!Oi?EZU)SOj7TR zJA)X6xW)Eu0I^_tsPlHi_pYEpnS}B<@N8$Y7~^IL`F0s?Gfxjy5(|yIhc6Vgiw~NP z{@Fed@O5$MB&1$_oVhG@fgL3EyhiIL85o>NFCgH8 z2~WXYF98bO>s}N_GJU;4xu%)eyF)h+>K2;rF(X_omx;oQ_dPTp{n;9$>K;R0E;)}% zClA@Fp$~F76{_bsD-i{bqP)&oI6%a+GUrGmTO{7Fy$?p9W(CSgSWWI6!v*gj28N($ z#=ko1Nwjd4Dn+v$m}wZicb2OJ0cDz+|IB}wlio=>pO}SjV%d4K$kD@lGxK z80cy?XTb6EXS*~S5DLuyDU$O=tc(~L{(EAJ%k!|jTn4@k(+jkyKLV|H+3h3~1&H?! z7gz4XFD@}GOa?h$$I6hAxF?s)opCG!zXv|@BLgb;J-b4`=xDMIU!xHT8@j70PZHie z*@6N^H*p3JGMjUWAuF00ATBdWT6@}3d7Xv*(Tty7X%vtT2$!Rms7+(9gbi{39Z4aE zNO|P(;$dxf1)M-hSjtVO;11iy_e+-O?(|nSikN-QtKj{Xm+<`wpPtb)#tA-`g>2EQ zFxzBLd_axuO%~e{gzz#{X1@=rc`Nhs1|SmP^$0v3lyMJRN7!CGF8;iqEKr|210{CU zc7RHa{no&?qIqxiN}07g)%xvl!@uV5ycYr9@%JN8n-^eR{I^Bri1PCzHcK)Jtb2Et z>A!!nB;&xk#9gKW?sRp@yG%uNreqpew``ZG)R!qq0P9xoGCdJsO6Gxen_?+OD?hVO z0NMwphHJKG02`wJeIfHZJ}*H=jK^u#A7(W{yG#c?d8_g%*X(eQhgDWUZQ{Y0!@Ho-jp>!wkp>0ZC?t{mbm(y!Y-2QQF);`a2l6xg-Cdlce>=vqo@ z-w0<;~vs2`us5@9PcttH|CqG|ntvZ^RN*DQd zI=6`yg2U}Sq3^yQ!k7dAYG5|W3(>yfyHfzsb*zh{sGn-LsA&gI$LI=9>%LtQPC~YB4M*)< nN_YP1)a{r#mx+H$Hh%c$4+PCpSBC&xc6dyU&5erAJLCTkF;Hqk literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/List-1.gif b/out/production/classes1/awt/doc-files/List-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..94b914685a844ff43424ff29d0b49304c22045a3 GIT binary patch literal 4193 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 V22DggJ+y9(Xx2M3v~3&E{~yF9>CXTF literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/MenuBar-1.gif b/out/production/classes1/awt/doc-files/MenuBar-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..af974f11b8d0793df1f14ee23b6911ef43f5fb3c GIT binary patch literal 2268 zcmV<22qX7LNk%w1VI2YM0HFW?0002Mz`+0i{{R30A^8LW00062EC2ui038AA00091 zgpaAq?GK}zwAzca-n{z{hT=$;=82~2%BsQ($MQ_q_KoNI&iDQg3<`(D*P@6_DwoWr z^O-zCr_`$TibYCafv)!p4vWX+viXcotJmzd`wfq~8!@^4j?e4&{QjN}<0m*sSZH{d z2grrU*y#8O8K)@lm1U_DnW`vh8ewN%NHQoLj@&0QbcKvqCb=CSWZmfQWr{qFFA%(Gty-^o-tF_tT~Zn(vCEZ zdW0vlrPG2ZB`!62ljqT=Ki>qU36rS2t*pdiWqS6e)21;$&QwcvrPY)TRc>Y5726hX zysRnJsk2>Kq;%0<&AKyc;4={ib1nS#aN)))73WR!RWd)yPaT_;{L!t{v7(ha##feYrThGcan)RV!ccS+RzWQEI`6&|{ zH;)83)_??x#~&pB)$*Qz3Ice4&(sa{8i42Gs5{V|R7$S-b z?uQDCGDhg)hz!c2N{%`{(P1|`{s`m{J>J+?kVYPv1C1#XNgk3;K52xK7WoKel|Z%# zqId{c$>okSehER8Tgp(QjbNTBg#t5_`3#zFCeUAz%CVV?O+&&d#+r1B#2$u62=sh8W@%v8tQ1E(8x6^r|x;0C7z)o znyF@{Nv3t>dC#|kh6~=fa%O8QsnY%RUA?@lLC=&dd!I#9^X#3+x+8J0ueJj5WgR#B@hBnZ zH8R2_JBV+)`o0_I%9@K zDo#)RCe+I|_%kgVk27-CT1$!SmWO(s(1R#P9W&YgfITJJYJ<$Sg>JuXa@?O@jU(N4 zn_ctVde3Zks$#GDH#331(={>~%W=5KjdSg{B*G#7!|B%IB+mHccJR&UdX2K7E{Ap868M{n}Gy&9Kn+$ls>CF!j2oxIm?$$l5iK2myd!XRX=e@d-t#z=A zVBQM1HVYySbRYzp2suW=5;Bm2d{W^5RLBh$4l0E(CjR-a zOGE?(4|(T7m=$q}Ryg7`Os7M7+)z^qu1H_(na#@fLQp!CXF5DpTz-fqk4) z4b}q^#;vh@bxh$S=b|ZLNotW7vE(c`QW~uk@KkIW9rbS zdW$gNGG*Bsxxn5qWnlw^i&nZRO+F^`gKq@nxiBW5#;nVmuCSxC+-W;_oV<(*EM-#fGYbn(UP5?-cqXfLe4?82zU~{kYLTQuLr9 zZRbcqT2febbcPH~>8MtU! zaRRqG)P;w%t~4SU~XB92j1$5SGwDzPBUlQoZ=3qea9^=u*m0Kq7oJ}B>4^g zPHPj}rU#ax%%5Zv`qoVfR;3Z{<|(-v-!kEqrWpPxS)a;Rvt}5?xD>I6lM3PhOLf2` zZmx+Tn#vZtwZky>rHo4q-xIeNh&-0jTYC&-6V)`xL~g-JZ;Ug8Az5ZhUUJEr>|{aq zF3KN+GL@mI@cMkHLsr-=U>wj z*TUwluZ!JlStEPZ%3gM?`Rwdl?>gGwJT|ojJnd_f0@T{Zwza!m&tQYw+sz)gvCD04 qazi`am;E-o0Y~h2=d8%|uD8AKjqiNxd*A%-x4-`l@PJpK002AneSoU~ literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/Modality.html b/out/production/classes1/awt/doc-files/Modality.html new file mode 100644 index 0000000..19695f0 --- /dev/null +++ b/out/production/classes1/awt/doc-files/Modality.html @@ -0,0 +1,471 @@ + + + + + + + + + The AWT Modality + + + + + +

The AWT Modality

+ +

+ This document, together with the API documentation for modality-related + classes (such as java.awt.Dialog), briefly describes the new + modality features and how to use them. It contains the following sections: +

+ + +

Definitions

+ +

+ Document - a window without an owner that, together with + all its child hierarchy, may be operated on as a single self-contained + document. + Every window belongs to some document — its root can be found as + the closest ancestor window without an owner. +

+ + Modal blocked window - a window, that: +

    +
  • doesn't receive any user input events +
  • doesn't receive input focus +
  • keeps its Z-order below the modal dialog that blocks it +
+
+
+ Warning! Some window managers allow users to change the window + Z-order in an arbitrary way — in that case the last requirement + may not be met. +
+
+

+ Modal dialog - a dialog that blocks some windows while it is + visible. The blocked windows are determined according to the dialog's + scope of blocking. +

+ Modal excluded window - a window that stays unblocked + while the modal dialog is visible. If a window is modal excluded + then all its owned windows and child components are also excluded. +

+ Scope of blocking (SB) - the set of windows (instances of + java.awt.Window and all derived classes) that are blocked by + the modal dialog while it is visible. +

+

+ Note: Everywhere in this document the notion of "window" is equal + to a top-level window in the Java programming language — in other words + an instance of java.awt.Window or any descendant class. +
+ + +

Modality types

+ +

+ There are four supported modality types : +

    +
  • toolkit +
  • application +
  • document +
  • modeless +
+ A dialog is, by default, modeless. A modal dialog is, by default, + application-modal. +

+

    +
  1. Modeless dialogs
    + A modeless dialog doesn't block any windows while visible. +
  2. Document-modal dialogs
    + A document-modal dialog blocks all windows from the same + document except those from its child hierarchy. The document root + is determined as the closest ancestor window without an + owner. +
  3. Application-modal dialogs
    + An application-modal dialog blocks all windows from the same + application except for those from its child hierarchy. + If there are several applets launched in a browser, they can be + treated either as separate applications or a single application. + This behavior is implementation-dependent. +
  4. Toolkit-modal dialogs
    + A toolkit-modal dialog blocks all windows that run in the same + toolkit except those from its child hierarchy. If there + are several applets launched all of them run with the same toolkit, + so a toolkit-modal dialog shown from an applet may affect other + applets and all windows of the browser instance which embeds the + Java runtime environment for this toolkit. + See the security section below. +
+

+ Modality priority is arranged by the strength of blocking: modeless, + document-modal, application-modal and toolkit-modal. This arrangement + is used when determining what dialog should remain unblocked if two + are visible and block each other. It naturally reflects the nesting + of a dialog's scope of blocking (SB): a modeless dialog has an empty SB, + a document-modal dialog's SB is complete in some applications, + and all the applications are run in one toolkit.

+ Notes about owners: +

    +
  • Creating a document-modal dialog without an owner:
    + Since Dialog is a class derived from + Window, a Dialog instance automatically + becomes the root of the document if it has no owner. Thus, if + such a dialog is document-modal, its scope of blocking is empty + and it behaves the same way as a modeless dialog. +
  • Creating an application-modal or toolkit-modal dialog with an + owner:
    + The scope of blocking for an application- or toolkit-modal + dialog, as opposed to a document-modal dialog, doesn't depend on + its owner. Thus, in this case the only thing that the owner + affects is the Z-order: the dialog always stays on top of its owner. +
+

+

+ Implementation note: Changing the modality type for a visible + dialog may have no effect until it is hidden and then shown again. +
+ + +

Show/hide blocking

+ +

+ Showing the window or modeless dialog: "F"
+ All the visible modal dialogs are looked through — if F is from the SB + of one of them, it becomes blocked by it. If there are several such + dialogs, the first shown is used. If no such dialogs exist, F remains + unblocked. +

+ Showing the modal dialog: "M"
+ When modal dialog M is shown, all the visible windows fall into one of + three distinct groups: +

    +
  • Blockers of M (modal dialogs that block M and + either are in M's child hierarchy, or are not blocked by M, or have + a greater mode of modality, or block some other blocker of M) +
  • Blocked by M (windows from M's SB that are not blockers and are + not in child hierarchy of any blocker) +
  • All other windows (windows or modeless + dialogs outside M's SB and modal dialogs outside M's SB that do not + block M). +
+

+ After the modal dialog M is shown, it becomes blocked by the first shown + dialog from the first group (if there are any), all the windows from the + second one become blocked by M, and all the windows from the third group + remain untouched. +

+ In typical cases, when no child dialogs are shown before their owners, + this rule can be simplified. (The following, simplified case, may + leave out some details). +

+ Showing the document-modal dialog: "M"
+ All the visible application- and toolkit-modal dialogs are looked + through — if M is from the SB of one of them, + it becomes blocked by it. If there are several such dialogs, + the first shown is used. If no such dialogs exist, M remains unblocked. +

+ Showing the application-modal dialog: "M"
+ All the visible toolkit-modal dialogs are looked through — + if M is from the SB of one of them, it becomes blocked by it. + If there are several such dialogs, the first shown is used. + If no such dialogs exist, M remains unblocked. +

+ Showing the toolkit-modal dialog: "M"
+ M remains unblocked. +

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
The Standard Blocking Matrix
current/shownframe & modelessdocumentapplicationtoolkit
-----
documentblocked---
applicationblockedblocked--
toolkitblockedblockedblocked-
+ +

+ After the modal dialog is shown, all the windows from its SB are blocked, + except those that block this modal dialog. +

+ Hiding the window or modeless dialog: "F"
+ If F was blocked by any modal dialog M, it becomes unblocked and is + removed from M's blocked windows list. +

+ Hiding the modal dialog: "M"
+ If M was blocked by any other modal dialog, for example, "N", + it becomes unblocked and + is removed from N's blocked windows list. Then, all the windows and dialogs + blocked by M become unblocked, and after that the same checks + (as in Showing the modal dialog: "M") + are performed for each of them in the order they were initially shown. + + +

Modal exclusion

+ +

+ There are two modal exclusion types introduced as of JDK 6 +

    +
  • Exclusion from blocking of toolkit-modal dialogs +
  • Exclusion from blocking of application-modal dialogs +
+ By default, a window's modal exclusion property is turned off. +

+

    +
  1. Application-modal exclusion
    + If a window is application-modal excluded, it is not blocked by any + application-modal dialogs. Also, it is not blocked by document-modal + dialogs from outside of its child hierarchy. +
  2. Toolkit-modal exclusion
    + If a window is toolkit-modal excluded, it is not blocked + by any application- or toolkit-modal dialogs. Also, it is not + blocked by document-modal dialogs from outside of their child hierarchy. +
+

+

+
+ Implementation note: Changing the modal exclusion type for a visible window + may have no effect until it is hidden and then shown again. +
+ + +

Related AWT features

+ +

+ Always-On-Top
+ When a modal dialog that is not always-on-top blocks an always-on-top window, + their relative Z-order is unspecified and platform-dependent. +

+

+ The toFront() and toBack() methods
+ A modal dialog should always be above all its blocked windows. Thus, if a blocked + window is brought to the front, its blocking dialog, if any, is also brought to the + front and remains above the blocked window. Likewise, if a modal dialog is sent to + the back, all of its blocked windows are sent to the back to keep them below the + blocking dialog. +

+

+ Minimizing, maximizing and closing blocked windows
+ When a modal dialog blocks a window, the user may not be able to maximize or + minimize the blocked window— however, the actual behavior is unspecified + and platform-dependent. In any case, the user can't close the blocked window + interactively— but it can be closed programmatically by calling the + setVisible(false) or dispose() methods on the blocked + window. +

+

+ Blocked windows activations
+ When the user selects a blocked window, it may be brought to the front, along + with the blocking modal dialog which would then become the active window— + however, the actual behavior is unspecified and platform-dependent. +

+

+ Hiding a modal dialog
+ When the modal dialog that currently has focus is hidden, it is unspecified + and platform-dependent, which other window will become the active window. + Any of the following may become the active window: +

    +
  1. The owner of the modal dialog - if the owner is unblocked. +
  2. The Window, which was active before this modal dialog gained + focus - if the owner of the modal dialog is absent or is blocked. +
+ If the modal dialog to be hidden does not have focus, the active window remains + unchanged. + + +

Security

+ +

+ A special AWTPermission, "toolkitModality", + is required to show toolkit-modal + dialogs. This would prevent, for example, blocking a browser or + Java Web Start (JWS) by modal dialogs shown from applets. +

+ The same permission is required to exclude a window from toolkit modality. + This would prevent, for example, a dialog shown from an applet not to be + blocked by a browser's or JWS's modal dialog. + + +

Platform support

+ +

+ Two java.awt.Toolkit methods allow you to check whether + the current platform supports specific modality features: +

    +
  • isModalityTypeSupported(modalityType)
    + Returns whether the specified modality type is supported on + the current platform. + If mode "M" is not supported and a dialog is set to M-modal, + it behaves as modeless. +
    • +
  • isModalExclusionTypeSupported(modalExclusionType)
    + Returns whether the given modal exclusion type is supported on + the current platform. If exclusion type "E" is not supported + and a window is marked as E-excluded, this has no effect. +
+ + +

Compatibility

+ +

+ The default modality type is application-modal. It is used by the API + calls: Dialog.setModal(true), + Dialog(owner, true), etc. Prior to JDK 6 + the default type was toolkit-modal, + but the only distinction between application- and toolkit-modality is for + applets and applications launched from Java Web Start. + + +

Examples

+ + + + + + + + + + + + + + + + + + +
+
    +
  1. Frame "F" is shown
    +
  2. Document-modal dialog "Di" is shown
    +
  3. F becomes blocked by Di — it's in the same document
    +
  4. Document-modal dialog "Dii" is shown
    +
  5. Di becomes blocked by Dii — it's in the + same document
    +
+
+ 		+ +
+
+
    +
  1. Frame "F" is shown
    +
  2. Document-modal dialog "Di" is shown
    +
  3. F becomes blocked by Di — it's in the same document
    +
  4. Document-modal dialog "Dii" is shown
    +
  5. Di becomes blocked by Dii — + it's in the same document
    +
  6. Di is hidden
    +
  7. F becomes blocked by Dii — it's in the same document
    +
+
+ 		+ +
+
+
    +
  1. Frame "F" is shown
    +
  2. Toolkit-modal dialog "Di" is created, but not shown
    +
  3. Document-modal dialog "Dii" is shown
    +
  4. F becomes blocked by Dii — it's in the same document
    +
  5. Application-modal dialog "Diii" is shown
    +
  6. Dii becomes blocked by Diii — + it's in the same application
    +
  7. Di is shown
    +
  8. Di becomes blocked by Dii — it's its owner
    +
  9. Diii remains unblocked — it blocks Dii and + Dii blocks Di
    +
+
+ 		+ +
+
+
    +
  1. Frame "F" is shown
    +
  2. Toolkit-modal dialog "Di" is created, but not shown
    +
  3. Document-modal dialog "Dii" is shown
    +
  4. F becomes blocked by Dii — it's in the same document
    +
  5. Application-modal dialog "Diii" is shown
    +
  6. Dii becomes blocked by Diii — it's in the + same application
    +
  7. Di is shown
    +
  8. Diii becomes blocked by Di — Di + is not blocked
    +
  9. Di remains unblocked
    +
+
+ 		+ +
+
+ + diff --git a/out/production/classes1/awt/doc-files/MultiScreen.gif b/out/production/classes1/awt/doc-files/MultiScreen.gif new file mode 100644 index 0000000000000000000000000000000000000000..ff85859453fcbaa2564ddcf6ebc3c9d2fe2b7215 GIT binary patch literal 3131 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 Vl~E~`Q%RLoX_Z%rl`UBS06S0o6F2|> literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/RadialGradientPaint-1.png b/out/production/classes1/awt/doc-files/RadialGradientPaint-1.png new file mode 100644 index 0000000000000000000000000000000000000000..8003b3a24fab3831753d3b9a44a74d4731aa5931 GIT binary patch literal 21911 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 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/RadialGradientPaint-2.png b/out/production/classes1/awt/doc-files/RadialGradientPaint-2.png new file mode 100644 index 0000000000000000000000000000000000000000..672b2170d3e925c5768e8be45bbe156c3b988fba GIT binary patch literal 25468 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ð*>j12g;0Da?Xl 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 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/RadialGradientPaint-3.png b/out/production/classes1/awt/doc-files/RadialGradientPaint-3.png new file mode 100644 index 0000000000000000000000000000000000000000..46484fdb766c04b23ba013e96ea703b1f9e4a7c5 GIT binary patch literal 14389 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 MNGeLyiWvp{A3O*pr~m)} literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/RadialGradientPaint-4.png b/out/production/classes1/awt/doc-files/RadialGradientPaint-4.png new file mode 100644 index 0000000000000000000000000000000000000000..6ab38c833ce8305fbb118642ba2b1c64188c4dd8 GIT binary patch literal 9784 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 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/Scrollbar-1.gif b/out/production/classes1/awt/doc-files/Scrollbar-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..f0e82aca66cea7ac12466f7fb4cfcf38d5b7f239 GIT binary patch literal 968 zcmV;(12_CfNk%w1VSNBy0HFW?0002Mz`+0i{{R30A^8LW00062EC2ui0DS;m00091 zgpaAq?GK}zwAzca-n{!S1mZ}R=82~2%C;`Mgzrq(_PxgV&iB5k`w53cQ}CrhC5;)| z(Up-gEdnVCQ*|n=t*G*nomRrMXV)Q!kxOVsl?!ZC)$ntou9DBU>nq*e7x%}9m$Ov{ zm`3w&PNY4j z2?fOw;8UkdX*DHB(;NkyMt63F3RG%Ut2c{oJxX<*(yL@2y!?t4TgtOT8@{=V_ioy< zKGXKqHx^gk!HV9}1)DTz;Ak>6wqvVUZDhWT8ebGPb?x8BluKD2*cJ_1tD6N8KF!jm zTeF!Xmu86ibmd5^y&jGmHD&C(pr_ETy%#v{u)0k;<}4iZ;42_@Rro$>?E)6hcTJktTjO*^Naic_f2Lz84ybQLaZKjZm^D zC6-iL*dkn0uGnOiPiCnlm_Fv$C4hL%re;xX3OEyi=G?bof~QSrCt(}%DCC?9LdV#j zBSwhYo&)A4k6~O5+MlA^!O2vYfGYGTYmU}6>5M^LdWm6-R%8*RekqktJdJwe3}B_E zDyCSgg34+<@UY4yscV=TE3F5ua>xwz6fBs_7~RnXOt_Pq)LW)NQ!tB1_}9b*drmk}75zWU@VaY2%gSI`<}< zZKn7ye0>`7CP)R3bns}=wV1FH3G?$Xnng@ZaSsqxjB&=1YRqxRqvw5Jgrno+v0p{e8LFh5RQom{NKoebGJlq9c=ZN`iw)W*gP zE60XuuEq=|lR-7~7a9~m0N zV~NXPCpa-;Uj1Ojf%pMhP#arv*DFmkA#Q7s*7)K#*#@^azNkZ$!O;WlO(PBAb;0!D z4$i9zQ(nTOfsW+xX45UXUq<7!5^nS(4mx_trNmraUU4Y36oRfOw|j9Kl6d z`O9sLl6t1PNqHxQuU6iTW1FjJ>8~*=I&PpqRh|7ot*Y_Ym;;PF>m=arL1zw7TjZeu z>PiCOYSyjDBz1jd0!PiJU4op7pcCM5)-oD^6x3KDG@Sc=QJnm>hFqYU)BHNgl?;xB zxDo|qzN+~#*fs9h4qaDlONJ4yIV+`YG+|cei`cWm;BL3ci|+u% z+?x{sHw)`JEpok?4?H=A=eyps2j?hSIH2ns(ZKZdzrnP*M~9Ub6-`Fvatqzm^PyYs zY3_!#={mbm0x*Q0t#30|(lvVTx6|D3l%j{Ht@GSsB!g zA&?B76S0|J6z^JOKWJWkv_g>lMiMu!=x)wf%kvJQbN{;DLh__+78+%PiO-O;9s;?R+^ z1YObTPltF3;ahT?^-oT@A(bwhun7x8J9Dz}(vakiXL1lHNzBuwZ~Tq8^*t%wIPPWtc`- z_kfY}H!O=7SF)^jnV)WT+VLa^?B3s7mNM+TTgx!>Gi~2`XBc0FWNr$w5{}%T&$q`o zV9%laiu+3(rs1#rQ=>$7y!r30?lUkgG36Zw$VC!rRUDTtdg6$Tz?W8qWmKd5cPfVu z|1`7*j3@c;%i8KR%`D#DgX$~CohSbqsz5#W3P5y4IHu5KyHtsO@^oTx=0xn3bdl)D s$5MoPY<%~|f>NlCTtW(E?b#{r4?r%KmK3oZ_XdfBPygs{VgmC17d;_v8UO$Q literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/TextArea-1.gif b/out/production/classes1/awt/doc-files/TextArea-1.gif new file mode 100644 index 0000000000000000000000000000000000000000..1e6217fac3d0d4283ff174ae1cf8f79adf3635ca GIT binary patch literal 2234 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 literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/modal-example1.gif b/out/production/classes1/awt/doc-files/modal-example1.gif new file mode 100644 index 0000000000000000000000000000000000000000..e6dfd56c8236e7a94438b84a47a93577e9cc5e61 GIT binary patch literal 2175 zcmb_bi$7HR7T@QH9QC<$5qXr?XbdrIM;>+4nK<5|Ll4T~WaoIL+z4GMqSC=|(Dn#J z^0;K8PL0l#DTGbMj2lKAbgJ9qHhGmRzq|JQ4R?J$^Vzdzt@T~s?|1F_-rd#SA@mY< z5?jRRNRxlk5r*Usc)~Xb`0f7}IEE1zMq(I6Z-NZRF`U3~62mDB zM|6?EF@nGd5+f*#Ky)vOV-Z%APIsZ2t@0HwUCh{K~e;XXt}@w ziWEsu6hR?S52T=%KqP@E0)ag618BlD*a7;11Ska700yLiCA0z$SPa+z4OobFjxIwE zL6Ib)jRbwL7BY$=DFnWPTwno35>X@qAHiub0C+(=7!7K{O7H_{!Zg?coIo%r1l9ls zq+t?h0S{OV*Z_^_6VcsJh8zOH#lT3=2WugtvHet zQMn!T5#$PKBsppNCUPD$upAm*2e=ZL2by4&;pbIfVVD|bLBG}Xe*#m6ec$N0wN!Sb zE331-&hrdAGMVc=%G~(8&TMVmCc~c1>&i9YTwLz2sWE zf2pzll(eVy+T#l6^aElu+q!<9K6lBap{;)Cns2qrc9y1bz_}vJozmobOBOb>p>L##UnwU>|-?0)cNBJ?cD$x;v??>8F6@o;Ki&32&2~P+6OD^-nZs{0i z6>d{IHX%r}4(akriU`dsvbJh=638Zt%6Dk}s-8F-;u$w==Vf>@K2l;G$046+H@FyXmZbaB5sl3omTmPx8lUGoE-f`ADY{H<>}WO44n= z-Y3owUl`U;*kEc}ou#1Ta+v#KUin~>&3DR!1->^IjQ+t+xHA^;kiCD})FtJUabHXdo* zbSG1wUL|-RVBF%YIA(snCf3o!tIPGaMeDh5qc(dF`eZfmB`otv|E|u9O_9H)divcG z5Noc~Zzubnw7yiv~C zzp_P9UmBhYnXjT`546lJG&(o@wEThR@YS>HLKlNzn;z5BwKnICi_2_!*~NEn>{d#Q zZtd2ZIDijqOI$9maOyrK>rqwLXZ!4Im-3%laiRk}+$StM9OYAu_o2f|C;6HXSDOIw`Vc=gbT1l1>Ra>r;fu z!=63fNuA8uG|?Jn-uQ{3RG--6FL%8eaGK5<^GT`N>+?l$Pw=$j)XzMZY46b%= zuvYWd4m)7LDtWbV*}8~X?Y&a@aKj(kf~zv?(08(q`fZxsSNJm<8?_(V{1BI2X6qkm zw|~!nSni_16S4xcAn|s8wHouJb=fxU9vT6@y`|c+d~*dwMm)p*+oh=R#UDk68RxDS zHRVR&Yi4x!PW5pH-fsHxqevUSsbOUL!9+!tWg6?e<;cRik~L?tRJxeLiv7Jtz1lO^ zg=XAvi+JxTsbqJNtSiN$b&G%WBg;3dazky>3*IM>dXFjxb7KUr&F4$J{seRx zN+s`Cbs8++dcA_Gw;v@O!xGDkzbKY!H1&$yj_3c9-^<$&PPpZ&-@cF|W;8pRSzDk literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/modal-example2.gif b/out/production/classes1/awt/doc-files/modal-example2.gif new file mode 100644 index 0000000000000000000000000000000000000000..65a0d25005ae9d3b9b87132eeeb3bff2b819d6ae GIT binary patch literal 2353 zcmb_bi$7F(8$T~8W-)^ym6XwHjPbS{xv!OIgp?+iXp(Ru^ZL}dq@{9cU5ctK#?SHlEg_0ClO5wdMN^@NSvZ@3IRtL z#Swuc5=Rt{U@Nc&Fdz*qffm$YF<=8UV8Jk=1<^SKNe~o4AX*=+g^VN#k|Ib%%LNut zq)39I2nvCEAO*byA_+th2;_kuKoh3H4$u!IKq0UOFdz*qp%r+*V!#Gyz(TZhbQy98 ziX;(jB+kWmy#A@CLC0t+aTh$0dA2u_0mzzf>JXiy7Qf*(K=roj&21cE^!um&(7 z4U<3%c)()7253Z|i0+0mkl(&dD>> z^>{n(HC5csVwrlCdNx;f9yi4I4hOM*60lW&NN2w;tm-a8F24MYl2!LlGevtNG+GEj ziAm(kVb8cdUS%#BjOE8z+@4aw;*arB-9O*UFDA^&%(waqy#vaQmEP~Ks__n#+v7&`*NMC?AKvxX{cRD`&$Qn5?G{OoXjMirPB%ThovE=XptaTFzs>my zxAGk_tKgiBr|&w0-_!|KmkfSvr{Y@1+I(D1A1Vf{Mc2-Rx8&V+|4DqOS@eyp&S^aQ z%0VGI;UlwKH>#6R#Z76`EoE=ASSuG9I&AD+H4|%~aIcZ1#BE^H!PR zrJ3o$ETL?bk^OYj`%uoK;jaz;6OU)IO12*^V@toc6F>1wx*+l|iPlU%73yU+ua+;c zGP02#?8#xTOuiwqdEu^D#g(RThXmXAb9B`>+>NZ0a`yY|%qomo^RCw9h-zY8(5ZlhGu2zU?&@K}Jt7CT z)e^@sovfT1Qb(#eXu8$Z>QME|0DI%rC-=nv#*R80r#m!pE|bH1?RQM2tF~f`+r<|# zKY!jBT@$9;&pqF*b*--Ih~#ESt+ZmMZks6VN8b8NvZ#x-jSEr##kA^Qmu{_(6WLmL zv{{=)Hx{}v#C|g0{>diixug7x_Dil$)gE<87FLdKeEYVbbE!qo_i<6(du2~t`j|$% zq)Y79VwXFbJd5GVfVzISh({(LPbx|p%GZuDSEAor(r@Tn^Lm*cEb#}SdQRo8cFgXL zIm3g^x035DlzXpg(sahS2cN9W1&CEAvMom1(x zoV{s&M>w16rma>opCEUx{&2f*L5Si>&*GB#MEUx2EYp?Wy7ulz!u+f!p@5v-NK2PZ{q^ zs$kCrb!Bb~UwI~K$jsplFS}zj(@u4C{ks=B8n%B1vm6E=?KCfFJxCB*@>S(K=T4TI z@J(iSspv5~E!Zlo3`yOqy2ac$j4VnCMQ=^yr$RVi)31 zpDq2QIuP`B&Dh@)e=v%jei`TQE-nlaac(+3(+`u_tB(x04>{Rhi9PhWTI!O;+Hyq3 zPMYvJ@sP!9?rx9$PuuZepMJ@WSN@kP`G-Qb%nxiyHi$f5;LROZPjo)g_3$*+_d-SO zOz+)#*BZ;nI@fsve{pnn#QPL4ZP(etWp@hph?Y-y4D9tg{?5i>Jfc>0HmJRRD4`@T z*@AyzY2ft8Ux8aDLmUUlt5>Zh-jZ*(YtQgp<)we82Pwjw945WHCRb;^8Pl^oRn%y9 z%uBo?#>~>&VW?NP@2Y(tbFb5l;GKB^S3<5_Hq7V`-lKhgf$Z9Y`q%@Cr_YSPU5PpU E58nSkF8}}l literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/doc-files/modal-example3.gif b/out/production/classes1/awt/doc-files/modal-example3.gif new file mode 100644 index 0000000000000000000000000000000000000000..f073bd7c7d69fe355ff69b453c08d42280f9a9ea GIT binary patch literal 2822 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 EKNQDbg8%>k literal 0 HcmV?d00001 diff --git a/out/production/classes1/awt/event/package.html b/out/production/classes1/awt/event/package.html new file mode 100644 index 0000000..5da7989 --- /dev/null +++ b/out/production/classes1/awt/event/package.html @@ -0,0 +1,58 @@ + + + + + + + +Provides interfaces and classes for dealing with different +types of events fired by AWT components. See the java.awt.AWTEvent +class for details on the AWT event model. Events are fired by event +sources. An event listener registers with an event source to receive +notifications about the events of a particular type. This package +defines events and event listeners, as well as event listener +adapters, which are convenience classes to make easier the process of +writing event listeners. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/awt/font/package.html b/out/production/classes1/awt/font/package.html new file mode 100644 index 0000000..22e71ba --- /dev/null +++ b/out/production/classes1/awt/font/package.html @@ -0,0 +1,53 @@ + + + + + + + +Provides classes and interface relating to fonts. It +contains support for representing Type 1, Type 1 Multiple Master +fonts, OpenType fonts, and TrueType fonts. + + + +@since 1.2 + + diff --git a/out/production/classes1/awt/geom/package.html b/out/production/classes1/awt/geom/package.html new file mode 100644 index 0000000..de8b62c --- /dev/null +++ b/out/production/classes1/awt/geom/package.html @@ -0,0 +1,63 @@ + + + + + + + +Provides the Java 2D classes for defining and performing operations +on objects related to two-dimensional geometry. Some important features +of the package include: +
    +
  • classes for manipulating geometry, such as AffineTransform and +the PathIterator interface which is implemented by all Shape objects. + +
  • classes that implement the Shape interface, such as +CubicCurve2D, Ellipse2D, Line2D, Rectangle2D, and GeneralShape. + +
  • the Area class which provides mechanisms for add (union), subtract, +intersect, and exclusiveOR operations on other Shape objects. +
+ + + +@since 1.2 + + diff --git a/out/production/classes1/awt/im/package.html b/out/production/classes1/awt/im/package.html new file mode 100644 index 0000000..552ca18 --- /dev/null +++ b/out/production/classes1/awt/im/package.html @@ -0,0 +1,69 @@ + + + + + + + + + + +

Provides classes and interfaces for the input method framework. +This package enables text editing components to receive text input +through input methods. Input methods are software components that let +the user enter text in ways other than simple typing on a keyboard. +They are commonly used to enter Japanese, Chinese, or Korean - +languages using thousands of different characters - on keyboards with +far fewer keys. However, the framework also supports input methods +for other languages and the use of entirely different input +mechanisms, such as handwriting or speech recognition.

+ +

Package Specification

+ + + +

Related Documentation

+ +

For overviews, tutorials, examples, guides, and tool +documentation, please see:

+ + + +@since 1.2 + + diff --git a/out/production/classes1/awt/im/spi/package.html b/out/production/classes1/awt/im/spi/package.html new file mode 100644 index 0000000..58e77ee --- /dev/null +++ b/out/production/classes1/awt/im/spi/package.html @@ -0,0 +1,126 @@ + + + + + + + Package java.awt.im.spi Description + + + + + +

Provides interfaces that enable the development of input methods +that can be used with any Java runtime environment. Input methods are +software components that let the user enter text in ways other than +simple typing on a keyboard. They are commonly used to enter +Japanese, Chinese, or Korean - languages using thousands of different +characters - on keyboards with far fewer keys. However, this package +also allows the development of input methods for other languages and +the use of entirely different input mechanisms, such as handwriting +recognition.

+ +

Package Specification

+ + + +

Packaging Input Methods

+ +

Input methods are packaged as installed extensions, as specified +by the Extension +Mechanism. The main JAR file of an input method must contain the +file:

+ +
    META-INF/services/java.awt.im.spi.InputMethodDescriptor
+ +

The file should contain a list of fully-qualified class names, one +per line, of classes implementing the +java.awt.im.spi.InputMethodDescriptor interface. Space +and tab characters surrounding each name, as well as blank lines, are +ignored. The comment character is '#' +(\u0023); on each line all characters following the +first comment character are ignored. The file must be encoded in +UTF-8.

+ +

For example, if the fully-qualified name of the class that +implements java.awt.im.spi.InputMethodDesciptor for the +Foo input method is +com.sun.ime.FooInputMethodDescriptor, the file +META-INF/services/java.awt.im.spi.InputMethodDescriptor +contains a line:

+ +
    com.sun.ime.FooInputMethodDescriptor
+ +

The input method must also provide at least two classes: one class +implementing the java.awt.im.spi.InputMethodDescriptor +interface, one class implementing the +java.awt.im.spi.InputMethod interface. The input method +should separate the implementations for these interfaces, so that +loading of the class implementing InputMethod can be +deferred until actually needed.

+ +

Loading Input Methods

+ +

The input method framework will usually defer loading of input +method classes until they are absolutely needed. It loads only the +InputMethodDescriptor implementations during AWT +initialization. It loads an InputMethod implementation +when the input method has been selected.

+ +

Java Input Methods and Peered Text +Components

+ +

The Java input method framework intends to support all +combinations of input methods (host input methods and Java input +methods) and components (peered and lightweight). However, because of +limitations in the underlying platform, it may not always be possible +to enable the communication between Java input methods and peered AWT +components. Support for this specific combination is therefore +platform dependent. In Sun's Java SE Runtime Environments, this +combination is supported on Windows, but not on Solaris.

+ +

Related Documentation

+ +

For overviews, tutorials, examples, guides, and tool +documentation, please see:

+ + + +@since JDK1.3 + + diff --git a/out/production/classes1/awt/image/package.html b/out/production/classes1/awt/image/package.html new file mode 100644 index 0000000..5f47da4 --- /dev/null +++ b/out/production/classes1/awt/image/package.html @@ -0,0 +1,58 @@ + + + + + + + +Provides classes for creating and modifying images. +Images are processed using a streaming framework that involves an +image producer, optional image filters, and an image consumer. This +framework makes it possible to progressively render an image while it +is being fetched and generated. Moreover, the framework allows an +application to discard the storage used by an image and to regenerate +it at any time. This package provides a number of image producers, +consumers, and filters that you can configure for your image +processing needs. + + +@since JDK1.0 + + diff --git a/out/production/classes1/awt/image/renderable/package.html b/out/production/classes1/awt/image/renderable/package.html new file mode 100644 index 0000000..c75fb1f --- /dev/null +++ b/out/production/classes1/awt/image/renderable/package.html @@ -0,0 +1,52 @@ + + + + + + + +Provides classes and interfaces for producing +rendering-independent images. + + + +@since 1.2 + + diff --git a/out/production/classes1/awt/package.html b/out/production/classes1/awt/package.html new file mode 100644 index 0000000..3d157e5 --- /dev/null +++ b/out/production/classes1/awt/package.html @@ -0,0 +1,83 @@ + + + + + + + +Contains all of the classes for creating user +interfaces and for painting graphics and images. A user interface object such as a button or a +scrollbar is called, in AWT terminology, a component. The Component class is the root of all +AWT components. See Component for a detailed description of properties that all AWT +components share. +

+Some components fire events when a user interacts with the components. The AWTEvent +class and its subclasses are used to represent the events that AWT components can fire. See +AWTEvent for a description of the AWT event model. +

+A container is a component that can contain components and other containers. A con +tainer can also have a layout manager that controls the visual placement of components in the +container. The AWT package contains several layout manager classes and an interface for +building your own layout manager. See Container and LayoutManager for more information. +

+Each {@code Component} object is limited in its maximum size and +its location because the values are stored as an integer. +Also, a platform may further restrict maximum size and location +coordinates. The exact maximum values are dependent on the platform. +There is no way to change these maximum values, either in Java +code or in native code. +These limitations also impose restrictions on component layout. +If the bounds of a Component object exceed a platform limit, +there is no way to properly arrange them within a Container object. +The object's bounds are defined by any object's coordinate +in combination with its size on a respective axis. + + +

Additional Specification

+ + + + +@since JDK1.0 + + diff --git a/out/production/classes1/awt/peer/package.html b/out/production/classes1/awt/peer/package.html new file mode 100644 index 0000000..aeb98b2 --- /dev/null +++ b/out/production/classes1/awt/peer/package.html @@ -0,0 +1,51 @@ + + + + + + +Provides for interfacing with the underlying window system. +It is for accessing the platform-specific facilities in order to +build AWT toolkits. It is only used by AWT toolkit developers. + + +

Package Specification

+ +##### FILL IN ANY SPECS NEEDED BY JAVA COMPATIBILITY KIT ##### + + +

Related Documentation

+ +For overviews, tutorials, examples, guides, and tool documentation, please see: + + + + + diff --git a/out/production/classes1/awt/print/package.html b/out/production/classes1/awt/print/package.html new file mode 100644 index 0000000..6c708d5 --- /dev/null +++ b/out/production/classes1/awt/print/package.html @@ -0,0 +1,58 @@ + + + + + + + +Provides classes and interfaces for a general printing API. The +API includes such features as: +
    +
  • the ability to specify document types +
  • mechanisms for control of page setup and page formats +
  • the ability to manage job control dialogs +
+ + + + +@since 1.2 + + diff --git a/out/production/classes1/beans/beancontext/package.html b/out/production/classes1/beans/beancontext/package.html new file mode 100644 index 0000000..739356e --- /dev/null +++ b/out/production/classes1/beans/beancontext/package.html @@ -0,0 +1,55 @@ + + + + + + +Provides classes and interfaces relating to bean context. +A bean context is a container for beans and defines the execution +environment for the beans it contains. There can be several beans in +a single bean context, and a bean context can be nested within another +bean context. This package also contains events and listener +interface for beans being added and removed from a bean context. + + + +@since 1.2 + + diff --git a/out/production/classes1/beans/package.html b/out/production/classes1/beans/package.html new file mode 100644 index 0000000..a1e7498 --- /dev/null +++ b/out/production/classes1/beans/package.html @@ -0,0 +1,156 @@ + + + + + + +Contains classes related to developing +beans -- components +based on the JavaBeans™ architecture. +A few of the +classes are used by beans while they run in an application. +For example, the event classes are +used by beans that fire property and vetoable change +events (see +{@link java.beans.PropertyChangeEvent}). However, most of the classes in this +package are meant to be used by a bean editor (that is, a development environment +for customizing and putting together beans to create an application). In +particular, these classes help the bean editor create a user +interface that the user can use to customize the bean. For example, a bean may +contain a property of a special type that a bean editor may not know how to handle. +By using the PropertyEditor interface, a bean developer can +provide an editor for this special type. + +

+To minimize the resources used by a bean, the classes used by bean editors are loaded only +when the bean is being edited. They are not needed while the bean is running in an application +and therefore not loaded. This information is kept in what's called a bean-info (see {@link java.beans.BeanInfo}). + +

+Unless explicitly stated, null values or empty Strings are not valid +parameters for the methods in this package. You may expect to see +exceptions if these parameters are used. + + +

Long-Term Persistence

+ +As of v1.4, +the java.beans package provides support for +long-term persistence -- reading and +writing a bean as a textual representation of its property values. +The property values are treated as beans, +and are recursively read or written to capture +their publicly available state. +This approach is suitable for long-term storage +because it relies only on public API, +rather than the likely-to-change private implementation. + +
+
+Note: +The persistence scheme cannot automatically instantiate +custom inner classes, such as you might use for event handlers. +By using the {@link java.beans.EventHandler} class +instead of inner classes for custom event handlers, +you can avoid this problem. +
+
+ +

+ +You read and write beans in XML format using the +{@link java.beans.XMLDecoder} +and +{@link java.beans.XMLEncoder} +classes, respectively. +One notable feature of the persistence scheme is that +reading in a bean requires no special knowledge of the bean. + +

+Writing out a bean, on the other hand, +sometimes requires special knowledge of the bean's type. +If the bean's state can be +expressed using only the no-argument constructor and +public getter and setter methods for properties, +no special knowledge is required. +Otherwise, the bean requires a custom persistence delegate -- +an object that is in charge of writing out beans of a particular type. +All classes provided in the JDK that descend +from java.awt.Component, +as well as all their properties, +automatically have persistence delegates. + +

+ +If you need (or choose) to provide a persistence delegate for a bean, +you can do so either by using a +{@link java.beans.DefaultPersistenceDelegate} +instance +or by creating your own subclass of PersistenceDelegate. +If the only reason a bean needs a persistence delegate +is because you want to invoke the bean's constructor with +property values as arguments, +you can create the bean's persistence delegate +with the one-argument +DefaultPersistenceDelegate +constructor. +Otherwise, +you need to implement your own persistence delegate, +for which you're likely to need the following classes: + +

+
{@link java.beans.PersistenceDelegate} +
The abstract class from which all persistence delegates descend. + Your subclass should use its knowledge of the bean's type to provide + whatever Statements and Expressions + are necessary to create the bean + and restore its state. +
{@link java.beans.Statement} +
Represents the invocation of a single method on an object. + Includes a set of arguments to the method. +
{@link java.beans.Expression} +
A subclass of Statement + used for methods that return a value. +
+ +

+Once you create a persistence delegate, +you register it using the +setPersistenceDelegate method of +XMLEncoder. + + +

Related Documentation

+ +For overview, architecture, and tutorial documentation, please see: + +

+ + + diff --git a/out/production/classes1/classes.iml b/out/production/classes1/classes.iml new file mode 100644 index 0000000..b107a2d --- /dev/null +++ b/out/production/classes1/classes.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/out/production/classes1/classes1.iml b/out/production/classes1/classes1.iml new file mode 100644 index 0000000..b107a2d --- /dev/null +++ b/out/production/classes1/classes1.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/out/production/classes1/io/package.html b/out/production/classes1/io/package.html new file mode 100644 index 0000000..1b909ad --- /dev/null +++ b/out/production/classes1/io/package.html @@ -0,0 +1,52 @@ + + + + + + +Provides for system input and output through data streams, +serialization and the file system. + +Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a +NullPointerException to be thrown. + +

Package Specification

+ + +

Related Documentation

+ +For overviews, tutorials, examples, guides, and tool documentation, +please see: + + +@since JDK1.0 + + diff --git a/out/production/classes1/lang/doc-files/ValueBased.html b/out/production/classes1/lang/doc-files/ValueBased.html new file mode 100644 index 0000000..7e1ee8b --- /dev/null +++ b/out/production/classes1/lang/doc-files/ValueBased.html @@ -0,0 +1,42 @@ + + + + Value-based Classes + + + +

Value-based Classes

+ +Some classes, such as java.util.Optional and +java.time.LocalDateTime, are value-based. Instances of a +value-based class: +
    +
  • are final and immutable (though may contain references to mutable + objects);
    • +
  • have implementations of equals, + hashCode, and toString which are computed + solely from the instance's state and not from its identity or the state + of any other object or variable;
    • +
  • make no use of identity-sensitive operations such as reference + equality (==) between instances, identity hash code of + instances, or synchronization on an instances's intrinsic lock;
    • +
  • are considered equal solely based on equals(), not + based on reference equality (==);
    • +
  • do not have accessible constructors, but are instead instantiated + through factory methods which make no committment as to the identity + of returned instances;
    • +
  • are freely substitutable when equal, meaning that interchanging + any two instances x and y that are equal + according to equals() in any computation or method + invocation should produce no visible change in behavior. +
    • +
+ +

A program may produce unpredictable results if it attempts to distinguish two + references to equal values of a value-based class, whether directly via reference + equality or indirectly via an appeal to synchronization, identity hashing, + serialization, or any other identity-sensitive mechanism. Use of such + identity-sensitive operations on instances of value-based classes may have + unpredictable effects and should be avoided.

+ + diff --git a/out/production/classes1/lang/doc-files/capchi.gif b/out/production/classes1/lang/doc-files/capchi.gif new file mode 100644 index 0000000000000000000000000000000000000000..8a506ebfb89bef96f3cbb29af83e468add67a301 GIT binary patch literal 144 zcmZ?wbhEHb@#^7F&Z8o~!3R&QLbiihbM=bSUwhl4wV%MaP7g sgOAR9nQ*Cbp+!6Q!c^&q5JuUeMFKu?YaJRdD)^GJUk4j zK=CIFBLf2?gAPa-WCjC^jKK-d)iO_Il$J$wZdFi<>`kqjC9*51d85W0Q&$FS0B#c> Ak^lez literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/capsigma.gif b/out/production/classes1/lang/doc-files/capsigma.gif new file mode 100644 index 0000000000000000000000000000000000000000..f75c3553b8eec054cc9e17284bc8ec1ee1bc89d6 GIT binary patch literal 131 zcmZ?wbhEHb9pW4wfr4EcoLr8Y9jz*t7nI~VWSml1Xx(bS o`e!Q(8{?$u$*S7zS5neEWsEqPk2i{ zNIX0|FfcGABqSIZ7ytkOA^8LW00031EC2ui01f~S000CzFvv-(y`iLS(J3^J9fJwoZo6KNOf|o(v2U(3NaFxOFqDmlA_D0At%VJpcdz literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/iota.gif b/out/production/classes1/lang/doc-files/iota.gif new file mode 100644 index 0000000000000000000000000000000000000000..d2dfc0d6ec0703a9ec2cb80aa0fb91732c712a9a GIT binary patch literal 112 zcmZ?wbhEHbCMz{sEjk^z~)z#?mK!gKZB%ROEbw8B2NCaX53dCqlHRXLH!%aRr>$Y2cs%Q7G+ literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/javalang.doc.anc21.gif b/out/production/classes1/lang/doc-files/javalang.doc.anc21.gif new file mode 100644 index 0000000000000000000000000000000000000000..7fe160aa6e894f308a51bc5ef6154a2768e96e34 GIT binary patch literal 206 zcmV;<05ShZNk%w1VLkvV0Du4h00030|NkNR1OWg50RSuj0000!04e|g0;Px1hsupQ=lag~{_nB@hr}7IxU;F2N2Eg8#5hl< zsK|#iEVV*W_lII}tV0?3c7CpCX7-n>{j8{aNB*bXx$dvWx#JM#kI!an#5tD3;nsHwAxH#%aA5vFR% IDp~*lJ03t^od5s; literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/javalang.doc.anc38.gif b/out/production/classes1/lang/doc-files/javalang.doc.anc38.gif new file mode 100644 index 0000000000000000000000000000000000000000..bccccfc5471d7fe8ddf0f1eccea503d6de26a0a6 GIT binary patch literal 220 zcmV<203-iLNk%w1VM+if0Du4h00030|NkNR1OWg50RSuj0000=04M+e0<(;Npb&}= zqnxzHg{|IPGskq|$bm*krs@;6>kG&7OxN~}=lWiwyzV<;hQZ&axVRWc#fF2mOeCeP zrZZ|mRV!1hM4QMy#beqSOctMRQ;-!>zPv^6bC(;3GU>rN9KRMe;RolFH|TN4b#!<5 zrQ+xmNkND(xrq4VSlMS;`LcO5cnL#9l$iOMVmjpI`U)E>J4;(D%BX7V8E8w&o2$vv WD%hY~e0$t0oFTq})^0029G0r5dH3`~=H`d3yTke8Vg5R|gsEb_Z= zts+O)WKX?CEHxRk*5ocp(SLca_|Bcwvq4`Ic*31ee9X1l-7)cT$h@R!&jh`clY(@# zH?X>SZV$}u<*sc#-2XA~`ML$GKPr{hnr**WWxekGcjg)8;uaOI(~cI;sCe3Xl%w;b n#z~Fjpy!NFT0~ZM?06KpQbMaLGvnm*$mx)bQYM)yBT^@Lvo(6NtZ{0+vWkh@&9vgS-+|se|F7rQg+?aWLsw`xgp;Tk tW=ApTNagZ0N$C@mXQRU<>3G!$%IFz)8B=6Ax%sKcx;Q%WD(h7M06SnDQ_uha literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/sigma1.gif b/out/production/classes1/lang/doc-files/sigma1.gif new file mode 100644 index 0000000000000000000000000000000000000000..cd4939b672a10f6dccbd67715280cea74990a72c GIT binary patch literal 135 zcmZ?wbhEHb1n0~jd&WMO1rU}Vq%@jzxUu$UN}@XR)SE}-4+)KOH>xM^ZgU literal 0 HcmV?d00001 diff --git a/out/production/classes1/lang/doc-files/theta.gif b/out/production/classes1/lang/doc-files/theta.gif new file mode 100644 index 0000000000000000000000000000000000000000..f953e4687c83eb9f1acd78fc5f0772e5355e2994 GIT binary patch literal 144 zcmZ?wbhEHb@#^7TbUmo~s?aRki&lcO{v2gjg__N?m#|0~jd&WMO1rU}Vq%@jzxUuoxMf@Lau?m9x_$woi%ktRpX + + + + + + + + + +Provides services that allow Java programming language agents to instrument programs running on the JVM. +The mechanism for instrumentation is modification of the byte-codes of methods. + +

Package Specification

+ +

+An agent is deployed as a JAR file. An attribute in the JAR file manifest specifies the +agent class which will be loaded to start the agent. For implementations that support a command-line +interface, an agent is started by specifying an option on the command-line. +Implementations may also support a mechanism to start agents some time after the VM has +started. For example, an implementation may provide a mechanism that allows a tool to +attach to a running application, and initiate the loading of the tool's agent into +the running application. The details as to how the load is initiated, is implementation +dependent. + +

Command-Line Interface

+ +

+An implementation is not required to provide a way to start agents from the +command-line interface. On implementations that do provide a way to start agents +from the command-line interface, an agent is started by adding this option to +the command-line: +

+-javaagent:jarpath[=options] +
+jarpath is the path to the agent JAR file. +options is the agent options. +This switch may be used multiple times on the same command-line, +thus creating multiple agents. +More than one agent may use the same jarpath. +An agent JAR file must conform to the JAR file specification. + +

+The manifest of the agent JAR file must contain the attribute Premain-Class. The +value of this attribute is the name of the agent class. The agent class must implement a +public static premain method similar in principle to the main application +entry point. After the Java Virtual Machine (JVM) has initialized, each premain method +will be called in the order the agents were specified, then the real application +main method will be called. +Each premain method must return in order for the startup sequence to proceed. + +

+The premain method has one of two possible signatures. The JVM first attempts to +invoke the following method on the agent class: + +

+public static void +premain(String agentArgs, Instrumentation inst); + +
+ +

+If the agent class does not implement this method then the JVM will attempt to invoke: + +

+public static void +premain(String agentArgs); + +
+ +

+The agent class may also have an agentmain method for use when the agent is started +after VM startup. When the agent is started using a command-line option, the agentmain +method is not invoked. + + +

+The agent class will be loaded by the system class loader +(see {@link java.lang.ClassLoader#getSystemClassLoader ClassLoader.getSystemClassLoader}). This is +the class loader which typically loads the class containing the application main method. +The premain methods will be run under the same security and classloader +rules as the application main method. +There are no modeling restrictions on what the agent premain method may do. +Anything application main can do, including creating threads, is legal from premain. + +

+Each agent is passed its agent options via the agentArgs parameter. +The agent options are passed as a single string, +any additional parsing should be performed by the agent itself. + +

+If the agent cannot be resolved +(for example, because the agent class cannot be loaded, +or because the agent class does not have an appropriate premain method), the JVM will abort. +If a premain method throws an uncaught exception, the JVM will abort. + + + +

Starting Agents After VM Startup

+ +

+An implementation may provide a mechanism to start agents sometime after the +the VM has started. The details as to how this is initiated are implementation +specific but typically the application has already started and its +main method has already been invoked. In cases where an implementation +supports the starting of agents after the VM has started the following applies: + +

    +

  1. The manifest of the agent JAR must contain the attribute Agent-Class. + The value of this attribute is the name of the agent class.

    2. + +

  2. The agent class must implement a public static agentmain method.

    3. + +

  3. The system class loader ( + {@link java.lang.ClassLoader#getSystemClassLoader ClassLoader.getSystemClassLoader}) must + support a mechanism to add an agent JAR file to the system class path.

    4. +
+ +

+The agent JAR is appended to the system class path. This is the class loader that typically loads +the class containing the application main method. The agent class is loaded and the +JVM attempts to invoke the agentmain method. The JVM first attempts to invoke +the following method on the agent class: + +

+public static void +agentmain(String agentArgs, Instrumentation inst); + +
+ +

+If the agent class does not implement this method then the JVM will attempt to invoke: + +

+public static void +agentmain(String agentArgs); + +
+ +

+The agent class may also have an premain method for use when the agent is started +using a command-line option. When the agent is started after VM startup the premain +method is not invoked. + + +

+The agent is passed its agent options via the agentArgs parameter. +The agent options are passed as a single string, +any additional parsing should be performed by the agent itself. + +

+The agentmain method should do any necessary initialization +required to start the agent. When startup is complete the method should +return. If the agent cannot be started +(for example, because the agent class cannot be loaded, +or because the agent class does not have a conformant agentmain method), the JVM will +not abort. If the agentmain method throws an uncaught exception it will be ignored. + + + +

Manifest Attributes

+The following manifest attributes are defined for an agent JAR file: +
+
+
Premain-Class
+
+ When an agent is specified at JVM launch time this attribute + specifies the agent class. + That is, the class containing the premain method. + When an agent is specified at JVM launch time this attribute + is required. If the attribute is not present the JVM will abort. + Note: this is a class name, not a file name or path. +
+ +
Agent-Class
+
+ If an implementation supports a mechanism to start agents + sometime after the VM has started then this attribute specifies + the agent class. + That is, the class containing the agentmain method. + This attribute is required, if it is not present the agent + will not be started. + Note: this is a class name, not a file name or path. +
+ +
Boot-Class-Path
+
+ A list of paths to be searched by the bootstrap class + loader. Paths represent directories or libraries + (commonly referred to as JAR or zip libraries on + many platforms). + These paths are searched by the + bootstrap class loader after the platform specific + mechanisms of locating a class have failed. + Paths are searched in the order listed. + Paths in the list are separated by one or more spaces. + A path takes the syntax of the path component of a + hierarchical URI. The path is + absolute if it begins with a slash character ('/'), + otherwise it is relative. A relative path is resolved + against the absolute path of the agent JAR file. + Malformed and non-existent paths are ignored. + When an agent is started sometime after the VM has + started then paths that do not represent a JAR file + are ignored. + This attribute is optional. +
+
Can-Redefine-Classes
+
+ Boolean (true or false, case irrelevant). + Is the ability to redefine classes + needed by this agent. + Values other than true are considered false. + This attribute is optional, the default is false. +
+
Can-Retransform-Classes
+
+ Boolean (true or false, case irrelevant). + Is the ability to retransform classes + needed by this agent. + Values other than true are considered false. + This attribute is optional, the default is false. +
+
Can-Set-Native-Method-Prefix
+
+ Boolean (true or false, case irrelevant). + Is the ability to set native method prefix needed by this agent. + Values other than true are considered false. + This attribute is optional, the default is false. +
+
+
+ +

+An agent JAR file may have both the Premain-Class and Agent-Class +attributes present in the manifest. When the agent is started on the command-line using +the -javaagent option then the Premain-Class attribute +specifies the name of the agent class and the Agent-Class attribute is +ignored. Similarly, if the agent is started sometime after the VM has started, then +the Agent-Class attribute specifies the name of the agent class +(the value of Premain-Class attribute is ignored). + +

Related Documentation

+ +For tool documentation, please see: + + +@since JDK1.5 +@revised 1.6 + + + diff --git a/out/production/classes1/lang/management/package.html b/out/production/classes1/lang/management/package.html new file mode 100644 index 0000000..829b3e8 --- /dev/null +++ b/out/production/classes1/lang/management/package.html @@ -0,0 +1,248 @@ + + + + + + +Provides the management interfaces for monitoring and management of the +Java virtual machine and other components in the Java runtime. +It allows both local and remote +monitoring and management of the running Java virtual machine. +

+ +

Platform MXBean

+

+A platform MXBean is a managed bean that +conforms to the JMX +Instrumentation Specification and only uses a set of basic data types. +Each platform MXBean is a {@link java.lang.management.PlatformManagedObject} +with a unique +{@linkplain java.lang.management.PlatformManagedObject#getObjectName name}. +

+

ManagementFactory

+ +

The {@link java.lang.management.ManagementFactory} class is the management +factory class for the Java platform. This class provides a set of +static factory methods to obtain the MXBeans for the Java platform +to allow an application to access the MXBeans directly. + +

A platform MBeanServer can be accessed with the +{@link java.lang.management.ManagementFactory#getPlatformMBeanServer + getPlatformMBeanServer} method. On the first call to this method, +it creates the platform MBeanServer and registers all platform MXBeans +including {@linkplain java.lang.management.PlatformManagedObject +platform MXBeans}. +Each platform MXBean is registered with a unique name defined in +the specification of the management interface. +This is a single MBeanServer that can be shared by different managed +components running within the same Java virtual machine. + +

Interoperability

+ +

A management application and a platform MBeanServer of a running +virtual machine can interoperate +without requiring classes used by the platform MXBean interfaces. +The data types being transmitted between the JMX connector +server and the connector client are JMX +{@linkplain javax.management.openmbean.OpenType open types} and +this allows interoperation across versions. +A data type used by the MXBean interfaces are mapped to an +open type when being accessed via MBeanServer interface. +See the +MXBean specification for details. + +

Ways to Access MXBeans

+ +

An application can monitor the instrumentation of the +Java virtual machine and the runtime in the following ways: +

+1. Direct access to an MXBean interface +

+

    +
  • Get an MXBean instance locally in the running Java virtual machine: +
    +   RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();
+
+   // Get the standard attribute "VmVendor"
+   String vendor = mxbean.getVmVendor();
+
    +

    Or by calling the + {@link java.lang.management.ManagementFactory#getPlatformMXBean(Class) + getPlatformMXBean} or + {@link java.lang.management.ManagementFactory#getPlatformMXBeans(Class) + getPlatformMXBeans} method: +

    +   RuntimeMXBean mxbean = ManagementFactory.getPlatformMXBean(RuntimeMXBean.class);
+
+   // Get the standard attribute "VmVendor"
+   String vendor = mxbean.getVmVendor();
+
    +

    +

    • +
  • Construct an MXBean proxy instance that forwards the + method calls to a given MBeanServer: +
    +   MBeanServerConnection mbs;
+
+   // Connect to a running JVM (or itself) and get MBeanServerConnection
+   // that has the JVM MBeans registered in it
+   ...
+
+   // Get a MBean proxy for RuntimeMXBean interface
+   RuntimeMXBean proxy =
+       {@link java.lang.management.ManagementFactory#getPlatformMXBean(MBeanServerConnection, Class)
+       ManagementFactory.getPlatformMXBean}(mbs,
+                                           RuntimeMXBean.class);
+   // Get standard attribute "VmVendor"
+   String vendor = proxy.getVmVendor();
+
    +

    A proxy is typically used to access an MXBean + in a remote Java virtual machine. + An alternative way to create an MXBean proxy is: +

    +   RuntimeMXBean proxy =
+       {@link java.lang.management.ManagementFactory#newPlatformMXBeanProxy
+              ManagementFactory.newPlatformMXBeanProxy}(mbs,
+                                                ManagementFactory.RUNTIME_MXBEAN_NAME,
+                                                RuntimeMXBean.class);
+
    +
    • +
+

+2. Indirect access to an MXBean interface via MBeanServer

+

    +
  • Go through the + {@link java.lang.management.ManagementFactory#getPlatformMBeanServer + platform MBeanServer} to access MXBeans locally or + a specific {@code MBeanServerConnection} to access + MXBeans remotely. + The attributes and operations of an MXBean use only + JMX open types which include basic data types, + {@link javax.management.openmbean.CompositeData CompositeData}, + and {@link javax.management.openmbean.TabularData TabularData} + defined in {@link javax.management.openmbean.OpenType OpenType}.

    +

    +   MBeanServerConnection mbs;
+
+   // Connect to a running JVM (or itself) and get MBeanServerConnection
+   // that has the JVM MXBeans registered in it
+   ...
+
+   try {
+       // Assuming the RuntimeMXBean has been registered in mbs
+       ObjectName oname = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
+
+       // Get standard attribute "VmVendor"
+       String vendor = (String) mbs.getAttribute(oname, "VmVendor");
+   } catch (....) {
+       // Catch the exceptions thrown by ObjectName constructor
+       // and MBeanServer.getAttribute method
+       ...
+   }
+
    +
    • +
+ + +

Platform Extension

+ +

A Java virtual machine implementation may add its platform extension to +the management interface by defining platform-dependent +interfaces that extend the standard management interfaces to include +platform-specific metrics and management operations. +The static factory methods in the ManagementFactory class will +return the MXBeans with the platform extension. + +

+It is recommended to name the platform-specific attributes with +a vendor-specific prefix such as the vendor's name to +avoid collisions of the attribute name between the future extension +to the standard management interface and the platform extension. +If the future extension to the standard management interface defines +a new attribute for a management interface and the attribute name +is happened to be same as some vendor-specific attribute's name, +the applications accessing that vendor-specific attribute would have +to be modified to cope with versioning and compatibility issues. + +

Below is an example showing how to access an attribute +from the platform extension: + +

+1) Direct access to the Oracle-specific MXBean interface +

+
+   List<com.sun.management.GarbageCollectorMXBean> mxbeans =
+       ManagementFactory.getPlatformMXBeans(com.sun.management.GarbageCollectorMXBean.class);
+
+   for (com.sun.management.GarbageCollectorMXBean gc : mxbeans) {
+       // Get the standard attribute "CollectionCount"
+       String count = mxbean.getCollectionCount();
+
+       // Get the platform-specific attribute "LastGcInfo"
+       GcInfo gcinfo = gc.getLastGcInfo();
+       ...
+   }
+
+
+ +

+2) Access the Oracle-specific MXBean interface via MBeanServer + through proxy + +

+   MBeanServerConnection mbs;
+
+   // Connect to a running JVM (or itself) and get MBeanServerConnection
+   // that has the JVM MXBeans registered in it
+   ...
+
+   List<com.sun.management.GarbageCollectorMXBean> mxbeans =
+       ManagementFactory.getPlatformMXBeans(mbs, com.sun.management.GarbageCollectorMXBean.class);
+
+   for (com.sun.management.GarbageCollectorMXBean gc : mxbeans) {
+       // Get the standard attribute "CollectionCount"
+       String count = mxbean.getCollectionCount();
+
+       // Get the platform-specific attribute "LastGcInfo"
+       GcInfo gcinfo = gc.getLastGcInfo();
+       ...
+   }
+
+ +

Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a {@link +java.lang.NullPointerException NullPointerException} to be thrown. + +

The java.lang.management API is thread-safe. + +@see + JMX Specification. + +@author Mandy Chung +@since 1.5 + + + diff --git a/out/production/classes1/lang/ref/package.html b/out/production/classes1/lang/ref/package.html new file mode 100644 index 0000000..f22a455 --- /dev/null +++ b/out/production/classes1/lang/ref/package.html @@ -0,0 +1,147 @@ + + + + + + + +Provides reference-object classes, which support a limited degree of +interaction with the garbage collector. A program may use a reference object +to maintain a reference to some other object in such a way that the latter +object may still be reclaimed by the collector. A program may also arrange to +be notified some time after the collector has determined that the reachability +of a given object has changed. + + +

Package Specification

+ +A reference object encapsulates a reference to some other object so +that the reference itself may be examined and manipulated like any other +object. Three types of reference objects are provided, each weaker than the +last: soft, weak, and phantom. Each type +corresponds to a different level of reachability, as defined below. Soft +references are for implementing memory-sensitive caches, weak references are +for implementing canonicalizing mappings that do not prevent their keys (or +values) from being reclaimed, and phantom references are for scheduling +pre-mortem cleanup actions in a more flexible way than is possible with the +Java finalization mechanism. + +

Each reference-object type is implemented by a subclass of the abstract +base {@link java.lang.ref.Reference} class. An instance of one of +these subclasses encapsulates a single reference to a particular object, called +the referent. Every reference object provides methods for getting and +clearing the reference. Aside from the clearing operation reference objects +are otherwise immutable, so no set operation is provided. A +program may further subclass these subclasses, adding whatever fields and +methods are required for its purposes, or it may use these subclasses without +change. + + +

Notification

+ +A program may request to be notified of changes in an object's reachability by +registering an appropriate reference object with a reference +queue at the time the reference object is created. Some time after the +garbage collector determines that the reachability of the referent has changed +to the value corresponding to the type of the reference, it will add the +reference to the associated queue. At this point, the reference is considered +to be enqueued. The program may remove references from a queue either +by polling or by blocking until a reference becomes available. Reference +queues are implemented by the {@link java.lang.ref.ReferenceQueue} +class. + +

The relationship between a registered reference object and its queue is +one-sided. That is, a queue does not keep track of the references that are +registered with it. If a registered reference becomes unreachable itself, then +it will never be enqueued. It is the responsibility of the program using +reference objects to ensure that the objects remain reachable for as long as +the program is interested in their referents. + +

While some programs will choose to dedicate a thread to removing reference +objects from one or more queues and processing them, this is by no means +necessary. A tactic that often works well is to examine a reference queue in +the course of performing some other fairly-frequent action. For example, a +hashtable that uses weak references to implement weak keys could poll its +reference queue each time the table is accessed. This is how the {@link +java.util.WeakHashMap} class works. Because the {@link +java.lang.ref.ReferenceQueue#poll ReferenceQueue.poll} method simply +checks an internal data structure, this check will add little overhead to the +hashtable access methods. + + +

Automatically-cleared references

+ +Soft and weak references are automatically cleared by the collector before +being added to the queues with which they are registered, if any. Therefore +soft and weak references need not be registered with a queue in order to be +useful, while phantom references do. An object that is reachable via phantom +references will remain so until all such references are cleared or themselves +become unreachable. + + + +

Reachability

+ +Going from strongest to weakest, the different levels of reachability reflect +the life cycle of an object. They are operationally defined as follows: + +
    + +
  • An object is strongly reachable if it can be reached by some +thread without traversing any reference objects. A newly-created object is +strongly reachable by the thread that created it. + +
  • An object is softly reachable if it is not strongly reachable but +can be reached by traversing a soft reference. + +
  • An object is weakly reachable if it is neither strongly nor +softly reachable but can be reached by traversing a weak reference. When the +weak references to a weakly-reachable object are cleared, the object becomes +eligible for finalization. + +
  • An object is phantom reachable if it is neither strongly, softly, +nor weakly reachable, it has been finalized, and some phantom reference refers +to it. + +
  • Finally, an object is unreachable, and therefore eligible for +reclamation, when it is not reachable in any of the above ways. + +
+ + +@author Mark Reinhold +@since 1.2 + + + + diff --git a/out/production/classes1/net/doc-files/net-properties.html b/out/production/classes1/net/doc-files/net-properties.html new file mode 100644 index 0000000..5aac0c8 --- /dev/null +++ b/out/production/classes1/net/doc-files/net-properties.html @@ -0,0 +1,242 @@ + + + + + + Networking Properties + + +

Networking Properties

+

There are a few standard system properties used to +alter the mechanisms and behavior of the various classes of the +java.net package. Some are checked only once at startup of the VM, +and therefore are best set using the -D option of the java command, +while others have a more dynamic nature and can also be changed using +the System.setProperty() API. The purpose of this document is to list +and detail all of these properties.

+

If there is no special note, a property value is checked every time it is used.

+ +

IPv4 / IPv6

+
    +

  • java.net.preferIPv4Stack (default: false)
    + If IPv6 is available on the operating system the + underlying native socket will be, by default, an IPv6 socket which + lets applications connect to, and accept connections from, both + IPv4 and IPv6 hosts. However, in the case an application would + rather use IPv4 only sockets, then this property can be set to true. + The implication is that it will not be possible for the application + to communicate with IPv6 only hosts.

    +

  • java.net.preferIPv6Addresses (default: false)
    + When dealing with a host which has both IPv4 + and IPv6 addresses, and if IPv6 is available on the operating + system, the default behavior is to prefer using IPv4 addresses over + IPv6 ones. This is to ensure backward compatibility, for example + applications that depend on the representation of an IPv4 address + (e.g. 192.168.1.1). This property can be set to true to + change that preference and use IPv6 addresses over IPv4 ones where + possible.

    +
+

Both of these properties are checked only once, at startup.

+ +

Proxies

+

A proxy server allows indirect connection to network services and +is used mainly for security (to get through firewalls) and +performance reasons (proxies often do provide caching mechanisms). +The following properties allow for configuration of the various type +of proxies.

+
    +

  • HTTP

    +

    The following proxy settings are used by the HTTP protocol handler.

    +
      +

    • http.proxyHost (default: <none>)
      + The hostname, or address, of the proxy server +

      +

    • http.proxyPort (default: 80)
      + The port number of the proxy server.

      +

    • http.nonProxyHosts (default: localhost|127.*|[::1])
      + Indicates the hosts that should be accessed without going + through the proxy. Typically this defines internal hosts. + The value of this property is a list of hosts, + separated by the '|' character. In addition the wildcard + character '*' can be used for pattern matching. For example + -Dhttp.nonProxyHosts=”*.foo.com|localhost” + will indicate that every hosts in the foo.com domain and the + localhost should be accessed directly even if a proxy server is + specified.

      +

      The default value excludes all common variations of the loopback address.

      +
    +

  • HTTPS
    This is HTTP over SSL, a secure version of HTTP + mainly used when confidentiality (like on payment sites) is needed.

    +

    The following proxy settings are used by the HTTPS protocol handler.

    +
      +

    • https.proxyHost(default: <none>)
      + The hostname, or address, of the proxy server +

      +

    • https.proxyPort (default: 443)
      + The port number of the proxy server.

      +

      The HTTPS protocol handler will use the same nonProxyHosts + property as the HTTP protocol.

      +
    +

  • FTP

    +

    The following proxy settings are used by the FTP protocol handler.

    +
      +

    • ftp.proxyHost(default: <none>)
      + The hostname, or address, of the proxy server +

      +

    • ftp.proxyPort (default: 80)
      + The port number of the proxy server.

      +

    • ftp.nonProxyHosts (default: localhost|127.*|[::1])
      + Indicates the hosts that should be accessed without going + through the proxy. Typically this defines internal hosts. + The value of this property is a list of hosts, separated by + the '|' character. In addition the wildcard character + '*' can be used for pattern matching. For example + -Dhttp.nonProxyHosts=”*.foo.com|localhost” + will indicate that every hosts in the foo.com domain and the + localhost should be accessed directly even if a proxy server is + specified.

      +

      The default value excludes all common variations of the loopback address.

      +
    +

  • SOCKS
    This is another type of proxy. It allows for lower + level type of tunneling since it works at the TCP level. In effect, + in the Java(tm) platform setting a SOCKS proxy server will result in + all TCP connections to go through that proxy, unless other proxies + are specified. If SOCKS is supported by a Java SE implementation, the + following properties will be used:

    +
      +

    • socksProxyHost (default: <none>)
      + The hostname, or address, of the proxy server.

      +

    • socksProxyPort (default: 1080)
      + The port number of the proxy server.

      +

    • socksProxyVersion (default: 5)
      + The version of the SOCKS protocol supported by the server. The + default is 5 indicating SOCKS V5, alternatively + 4 can be specified for SOCKS V4. Setting the property + to values other than these leads to unspecified behavior.

      +

    • java.net.socks.username (default: <none>)
      + Username to use if the SOCKSv5 server asks for authentication + and no java.net.Authenticator instance was found.

      +

    • java.net.socks.password (default: <none>)
      + Password to use if the SOCKSv5 server asks for authentication + and no java.net.Authenticator instance was found.

      +

      Note that if no authentication is provided with either the above + properties or an Authenticator, and the proxy requires one, then + the user.name property will be used with no password.

      +
    +

  • java.net.useSystemProxies (default: false)
    + On recent Windows systems and on Gnome 2.x systems it is possible to + tell the java.net stack, setting this property to true, to use + the system proxy settings (both these systems let you set proxies + globally through their user interface). Note that this property is + checked only once at startup.

    +
+ +

Misc HTTP properties

+
    +

  • http.agent (default: “Java/<version>”)
    + Defines the string sent in the User-Agent request header in http + requests. Note that the string “Java/<version>” will + be appended to the one provided in the property (e.g. if + -Dhttp.agent=”foobar” is used, the User-Agent header will + contain “foobar Java/1.5.0” if the version of the VM is + 1.5.0). This property is checked only once at startup.

    +

  • http.keepalive (default: true)
    + Indicates if persistent connections should be supported. They improve + performance by allowing the underlying socket connection to be reused + for multiple http requests. If this is set to true then persistent + connections will be requested with HTTP 1.1 servers.

    +

  • http.maxConnections (default: 5)
    + If HTTP keepalive is enabled (see above) this value determines the + maximum number of idle connections that will be simultaneously kept + alive, per destination.

    +

  • http.maxRedirects (default: 20)
    + This integer value determines the maximum number, for a given request, + of HTTP redirects that will be automatically followed by the + protocol handler.

    +

  • http.auth.digest.validateServer (default: false)

    +

  • http.auth.digest.validateProxy (default: false)

    +

  • http.auth.digest.cnonceRepeat (default: 5)

    +

    These 3 properties modify the behavior of the HTTP digest + authentication mechanism. Digest authentication provides a limited + ability for the server to authenticate itself to the client (i.e. + By proving it knows the user's password). However not all HTTP + servers support this capability and by default it is turned off. The + first two properties can be set to true to enforce this check for + authentication with either an origin or proxy server, respectively.

    +

    It is usually not necessary to change the third property. It + determines how many times a cnonce value is re-used. This can be + useful when the MD5-sess algorithm is being used. Increasing this + value reduces the computational overhead on both client and server + by reducing the amount of material that has to be hashed for each + HTTP request.

    +

  • http.auth.ntlm.domain (default: <none>)
    + NTLM is another authentication scheme. It uses the + java.net.Authenticator class to acquire usernames and passwords when + they are needed. However NTLM also needs the NT domain name. There are + 3 options for specifying that domain:

    +
      +

    1. Do not specify it. In some environments the domain is + actually not required and the application does not have to specify + it.

      +

    2. The domain name can be encoded within the username by + prefixing the domain name, followed by a back-slash '\' before the + username. With this method existing applications that use the + authenticator class do not need to be modified, as long as users + are made aware that this notation must be used.

      +

    3. If a domain name is not specified as in method 2) and these + property is defined, then its value will be used a the domain + name.

      +
    +
+

All these properties are checked only once at startup.

+ +

Address Cache

+

The java.net package, when doing name resolution, uses an address +cache for both security and performance reasons. Any address +resolution attempt, be it forward (name to IP address) or reverse (IP +address to name), will have its result cached, whether it was +successful or not, so that subsequent identical requests will not +have to access the naming service. These properties allow for some +tuning on how the cache is operating.

+
    +

  • networkaddress.cache.ttl (default: see below)
    + Value is an integer corresponding to the number of seconds successful + name lookups will be kept in the cache. A value of -1, or any other + negative value for that matter, indicates a “cache forever” + policy, while a value of 0 (zero) means no caching. The default value + is -1 (forever) if a security manager is installed, and implementation + specific when no security manager is installed.

    +

  • networkaddress.cache.negative.ttl (default: 10)
    + Value is an integer corresponding to the number of seconds an + unsuccessful name lookup will be kept in the cache. A value of -1, + or any negative value, means “cache forever”, while a + value of 0 (zero) means no caching.

    +
+

Since these 2 properties are part of the security policy, they are +not set by either the -D option or the System.setProperty() API, +instead they are set as security properties.

+ + diff --git a/out/production/classes1/nio/ByteBufferAs-X-Buffer.java.template b/out/production/classes1/nio/ByteBufferAs-X-Buffer.java.template new file mode 100644 index 0000000..bae6225 --- /dev/null +++ b/out/production/classes1/nio/ByteBufferAs-X-Buffer.java.template @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2000, 2013, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +package java.nio; + + +class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private + extends {#if[ro]?ByteBufferAs}$Type$Buffer{#if[ro]?$BO$} +{ + +#if[rw] + + protected final ByteBuffer bb; + protected final int offset; + +#end[rw] + + ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb) { // package-private +#if[rw] + super(-1, 0, + bb.remaining() >> $LG_BYTES_PER_VALUE$, + bb.remaining() >> $LG_BYTES_PER_VALUE$); + this.bb = bb; + // enforce limit == capacity + int cap = this.capacity(); + this.limit(cap); + int pos = this.position(); + assert (pos <= cap); + offset = pos; +#else[rw] + super(bb); +#end[rw] + } + + ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb, + int mark, int pos, int lim, int cap, + int off) + { +#if[rw] + super(mark, pos, lim, cap); + this.bb = bb; + offset = off; +#else[rw] + super(bb, mark, pos, lim, cap, off); +#end[rw] + } + + public $Type$Buffer slice() { + int pos = this.position(); + int lim = this.limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + int off = (pos << $LG_BYTES_PER_VALUE$) + offset; + assert (off >= 0); + return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, -1, 0, rem, rem, off); + } + + public $Type$Buffer duplicate() { + return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + offset); + } + + public $Type$Buffer asReadOnlyBuffer() { +#if[rw] + return new ByteBufferAs$Type$BufferR$BO$(bb, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + offset); +#else[rw] + return duplicate(); +#end[rw] + } + +#if[rw] + + protected int ix(int i) { + return (i << $LG_BYTES_PER_VALUE$) + offset; + } + + public $type$ get() { + return Bits.get$Type$$BO$(bb, ix(nextGetIndex())); + } + + public $type$ get(int i) { + return Bits.get$Type$$BO$(bb, ix(checkIndex(i))); + } + +#if[streamableType] + $type$ getUnchecked(int i) { + return Bits.get$Type$$BO$(bb, ix(i)); + } +#end[streamableType] + +#end[rw] + + public $Type$Buffer put($type$ x) { +#if[rw] + Bits.put$Type$$BO$(bb, ix(nextPutIndex()), x); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put(int i, $type$ x) { +#if[rw] + Bits.put$Type$$BO$(bb, ix(checkIndex(i)), x); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer compact() { +#if[rw] + int pos = position(); + int lim = limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + + ByteBuffer db = bb.duplicate(); + db.limit(ix(lim)); + db.position(ix(0)); + ByteBuffer sb = db.slice(); + sb.position(pos << $LG_BYTES_PER_VALUE$); + sb.compact(); + position(rem); + limit(capacity()); + discardMark(); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public boolean isDirect() { + return bb.isDirect(); + } + + public boolean isReadOnly() { + return {#if[rw]?false:true}; + } + +#if[char] + + public String toString(int start, int end) { + if ((end > limit()) || (start > end)) + throw new IndexOutOfBoundsException(); + try { + int len = end - start; + char[] ca = new char[len]; + CharBuffer cb = CharBuffer.wrap(ca); + CharBuffer db = this.duplicate(); + db.position(start); + db.limit(end); + cb.put(db); + return new String(ca); + } catch (StringIndexOutOfBoundsException x) { + throw new IndexOutOfBoundsException(); + } + } + + + // --- Methods to support CharSequence --- + + public CharBuffer subSequence(int start, int end) { + int pos = position(); + int lim = limit(); + assert (pos <= lim); + pos = (pos <= lim ? pos : lim); + int len = lim - pos; + + if ((start < 0) || (end > len) || (start > end)) + throw new IndexOutOfBoundsException(); + return new ByteBufferAsCharBuffer$RW$$BO$(bb, + -1, + pos + start, + pos + end, + capacity(), + offset); + } + +#end[char] + + + public ByteOrder order() { +#if[boB] + return ByteOrder.BIG_ENDIAN; +#end[boB] +#if[boL] + return ByteOrder.LITTLE_ENDIAN; +#end[boL] + } + +} diff --git a/out/production/classes1/nio/Direct-X-Buffer-bin.java.template b/out/production/classes1/nio/Direct-X-Buffer-bin.java.template new file mode 100644 index 0000000..538bd5f --- /dev/null +++ b/out/production/classes1/nio/Direct-X-Buffer-bin.java.template @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2000, 2003, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +class XXX { + +#begin + +#if[rw] + + private $type$ get$Type$(long a) { + if (unaligned) { + $memtype$ x = unsafe.get$Memtype$(a); + return $fromBits$(nativeByteOrder ? x : Bits.swap(x)); + } + return Bits.get$Type$(a, bigEndian); + } + + public $type$ get$Type$() { + return get$Type$(ix(nextGetIndex($BYTES_PER_VALUE$))); + } + + public $type$ get$Type$(int i) { + return get$Type$(ix(checkIndex(i, $BYTES_PER_VALUE$))); + } + +#end[rw] + + private ByteBuffer put$Type$(long a, $type$ x) { +#if[rw] + if (unaligned) { + $memtype$ y = $toBits$(x); + unsafe.put$Memtype$(a, (nativeByteOrder ? y : Bits.swap(y))); + } else { + Bits.put$Type$(a, x, bigEndian); + } + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public ByteBuffer put$Type$($type$ x) { +#if[rw] + put$Type$(ix(nextPutIndex($BYTES_PER_VALUE$)), x); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public ByteBuffer put$Type$(int i, $type$ x) { +#if[rw] + put$Type$(ix(checkIndex(i, $BYTES_PER_VALUE$)), x); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer as$Type$Buffer() { + int off = this.position(); + int lim = this.limit(); + assert (off <= lim); + int rem = (off <= lim ? lim - off : 0); + + int size = rem >> $LG_BYTES_PER_VALUE$; + if (!unaligned && ((address + off) % $BYTES_PER_VALUE$ != 0)) { + return (bigEndian + ? ($Type$Buffer)(new ByteBufferAs$Type$Buffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : ($Type$Buffer)(new ByteBufferAs$Type$Buffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } else { + return (nativeByteOrder + ? ($Type$Buffer)(new Direct$Type$Buffer$RW$U(this, + -1, + 0, + size, + size, + off)) + : ($Type$Buffer)(new Direct$Type$Buffer$RW$S(this, + -1, + 0, + size, + size, + off))); + } + } + +#end + +} diff --git a/out/production/classes1/nio/Direct-X-Buffer.java.template b/out/production/classes1/nio/Direct-X-Buffer.java.template new file mode 100644 index 0000000..57801f7 --- /dev/null +++ b/out/production/classes1/nio/Direct-X-Buffer.java.template @@ -0,0 +1,490 @@ +/* + * Copyright (c) 2000, 2013, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +package java.nio; + +import java.io.FileDescriptor; +import sun.misc.Cleaner; +import sun.misc.Unsafe; +import sun.misc.VM; +import sun.nio.ch.DirectBuffer; + + +class Direct$Type$Buffer$RW$$BO$ +#if[rw] + extends {#if[byte]?Mapped$Type$Buffer:$Type$Buffer} +#else[rw] + extends Direct$Type$Buffer$BO$ +#end[rw] + implements DirectBuffer +{ + +#if[rw] + + // Cached unsafe-access object + protected static final Unsafe unsafe = Bits.unsafe(); + + // Cached array base offset + private static final long arrayBaseOffset = (long)unsafe.arrayBaseOffset($type$[].class); + + // Cached unaligned-access capability + protected static final boolean unaligned = Bits.unaligned(); + + // Base address, used in all indexing calculations + // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress + // protected long address; + + // An object attached to this buffer. If this buffer is a view of another + // buffer then we use this field to keep a reference to that buffer to + // ensure that its memory isn't freed before we are done with it. + private final Object att; + + public Object attachment() { + return att; + } + +#if[byte] + + private static class Deallocator + implements Runnable + { + + private static Unsafe unsafe = Unsafe.getUnsafe(); + + private long address; + private long size; + private int capacity; + + private Deallocator(long address, long size, int capacity) { + assert (address != 0); + this.address = address; + this.size = size; + this.capacity = capacity; + } + + public void run() { + if (address == 0) { + // Paranoia + return; + } + unsafe.freeMemory(address); + address = 0; + Bits.unreserveMemory(size, capacity); + } + + } + + private final Cleaner cleaner; + + public Cleaner cleaner() { return cleaner; } + +#else[byte] + + public Cleaner cleaner() { return null; } + +#end[byte] + +#end[rw] + +#if[byte] + + // Primary constructor + // + Direct$Type$Buffer$RW$(int cap) { // package-private +#if[rw] + super(-1, 0, cap, cap); + boolean pa = VM.isDirectMemoryPageAligned(); + int ps = Bits.pageSize(); + long size = Math.max(1L, (long)cap + (pa ? ps : 0)); + Bits.reserveMemory(size, cap); + + long base = 0; + try { + base = unsafe.allocateMemory(size); + } catch (OutOfMemoryError x) { + Bits.unreserveMemory(size, cap); + throw x; + } + unsafe.setMemory(base, size, (byte) 0); + if (pa && (base % ps != 0)) { + // Round up to page boundary + address = base + ps - (base & (ps - 1)); + } else { + address = base; + } + cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); + att = null; +#else[rw] + super(cap); +#end[rw] + } + +#if[rw] + + // Invoked to construct a direct ByteBuffer referring to the block of + // memory. A given arbitrary object may also be attached to the buffer. + // + Direct$Type$Buffer(long addr, int cap, Object ob) { + super(-1, 0, cap, cap); + address = addr; + cleaner = null; + att = ob; + } + + + // Invoked only by JNI: NewDirectByteBuffer(void*, long) + // + private Direct$Type$Buffer(long addr, int cap) { + super(-1, 0, cap, cap); + address = addr; + cleaner = null; + att = null; + } + +#end[rw] + + // For memory-mapped buffers -- invoked by FileChannelImpl via reflection + // + protected Direct$Type$Buffer$RW$(int cap, long addr, + FileDescriptor fd, + Runnable unmapper) + { +#if[rw] + super(-1, 0, cap, cap, fd); + address = addr; + cleaner = Cleaner.create(this, unmapper); + att = null; +#else[rw] + super(cap, addr, fd, unmapper); +#end[rw] + } + +#end[byte] + + // For duplicates and slices + // + Direct$Type$Buffer$RW$$BO$(DirectBuffer db, // package-private + int mark, int pos, int lim, int cap, + int off) + { +#if[rw] + super(mark, pos, lim, cap); + address = db.address() + off; +#if[byte] + cleaner = null; +#end[byte] + att = db; +#else[rw] + super(db, mark, pos, lim, cap, off); +#end[rw] + } + + public $Type$Buffer slice() { + int pos = this.position(); + int lim = this.limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + int off = (pos << $LG_BYTES_PER_VALUE$); + assert (off >= 0); + return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, off); + } + + public $Type$Buffer duplicate() { + return new Direct$Type$Buffer$RW$$BO$(this, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + 0); + } + + public $Type$Buffer asReadOnlyBuffer() { +#if[rw] + return new Direct$Type$BufferR$BO$(this, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + 0); +#else[rw] + return duplicate(); +#end[rw] + } + +#if[rw] + + public long address() { + return address; + } + + private long ix(int i) { + return address + (i << $LG_BYTES_PER_VALUE$); + } + + public $type$ get() { + return $fromBits$($swap$(unsafe.get$Swaptype$(ix(nextGetIndex())))); + } + + public $type$ get(int i) { + return $fromBits$($swap$(unsafe.get$Swaptype$(ix(checkIndex(i))))); + } + +#if[streamableType] + $type$ getUnchecked(int i) { + return $fromBits$($swap$(unsafe.get$Swaptype$(ix(i)))); + } +#end[streamableType] + + public $Type$Buffer get($type$[] dst, int offset, int length) { +#if[rw] + if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) { + checkBounds(offset, length, dst.length); + int pos = position(); + int lim = limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + if (length > rem) + throw new BufferUnderflowException(); + +#if[!byte] + if (order() != ByteOrder.nativeOrder()) + Bits.copyTo$Memtype$Array(ix(pos), dst, + offset << $LG_BYTES_PER_VALUE$, + length << $LG_BYTES_PER_VALUE$); + else +#end[!byte] + Bits.copyToArray(ix(pos), dst, arrayBaseOffset, + offset << $LG_BYTES_PER_VALUE$, + length << $LG_BYTES_PER_VALUE$); + position(pos + length); + } else { + super.get(dst, offset, length); + } + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + +#end[rw] + + public $Type$Buffer put($type$ x) { +#if[rw] + unsafe.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x))); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put(int i, $type$ x) { +#if[rw] + unsafe.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x))); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put($Type$Buffer src) { +#if[rw] + if (src instanceof Direct$Type$Buffer$BO$) { + if (src == this) + throw new IllegalArgumentException(); + Direct$Type$Buffer$RW$$BO$ sb = (Direct$Type$Buffer$RW$$BO$)src; + + int spos = sb.position(); + int slim = sb.limit(); + assert (spos <= slim); + int srem = (spos <= slim ? slim - spos : 0); + + int pos = position(); + int lim = limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + + if (srem > rem) + throw new BufferOverflowException(); + unsafe.copyMemory(sb.ix(spos), ix(pos), srem << $LG_BYTES_PER_VALUE$); + sb.position(spos + srem); + position(pos + srem); + } else if (src.hb != null) { + + int spos = src.position(); + int slim = src.limit(); + assert (spos <= slim); + int srem = (spos <= slim ? slim - spos : 0); + + put(src.hb, src.offset + spos, srem); + src.position(spos + srem); + + } else { + super.put(src); + } + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put($type$[] src, int offset, int length) { +#if[rw] + if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) { + checkBounds(offset, length, src.length); + int pos = position(); + int lim = limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + if (length > rem) + throw new BufferOverflowException(); + +#if[!byte] + if (order() != ByteOrder.nativeOrder()) + Bits.copyFrom$Memtype$Array(src, offset << $LG_BYTES_PER_VALUE$, + ix(pos), length << $LG_BYTES_PER_VALUE$); + else +#end[!byte] + Bits.copyFromArray(src, arrayBaseOffset, offset << $LG_BYTES_PER_VALUE$, + ix(pos), length << $LG_BYTES_PER_VALUE$); + position(pos + length); + } else { + super.put(src, offset, length); + } + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer compact() { +#if[rw] + int pos = position(); + int lim = limit(); + assert (pos <= lim); + int rem = (pos <= lim ? lim - pos : 0); + + unsafe.copyMemory(ix(pos), ix(0), rem << $LG_BYTES_PER_VALUE$); + position(rem); + limit(capacity()); + discardMark(); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public boolean isDirect() { + return true; + } + + public boolean isReadOnly() { + return {#if[rw]?false:true}; + } + + +#if[char] + + public String toString(int start, int end) { + if ((end > limit()) || (start > end)) + throw new IndexOutOfBoundsException(); + try { + int len = end - start; + char[] ca = new char[len]; + CharBuffer cb = CharBuffer.wrap(ca); + CharBuffer db = this.duplicate(); + db.position(start); + db.limit(end); + cb.put(db); + return new String(ca); + } catch (StringIndexOutOfBoundsException x) { + throw new IndexOutOfBoundsException(); + } + } + + + // --- Methods to support CharSequence --- + + public CharBuffer subSequence(int start, int end) { + int pos = position(); + int lim = limit(); + assert (pos <= lim); + pos = (pos <= lim ? pos : lim); + int len = lim - pos; + + if ((start < 0) || (end > len) || (start > end)) + throw new IndexOutOfBoundsException(); + return new DirectCharBuffer$RW$$BO$(this, + -1, + pos + start, + pos + end, + capacity(), + offset); + } + +#end[char] + + + +#if[!byte] + + public ByteOrder order() { +#if[boS] + return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) + ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN); +#end[boS] +#if[boU] + return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN) + ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN); +#end[boU] + } + +#end[!byte] + + + +#if[byte] + + byte _get(int i) { // package-private + return unsafe.getByte(address + i); + } + + void _put(int i, byte b) { // package-private +#if[rw] + unsafe.putByte(address + i, b); +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + // #BIN + // + // Binary-data access methods for short, char, int, long, float, + // and double will be inserted here + +#end[byte] + +} diff --git a/out/production/classes1/nio/Heap-X-Buffer.java.template b/out/production/classes1/nio/Heap-X-Buffer.java.template new file mode 100644 index 0000000..e8639c4 --- /dev/null +++ b/out/production/classes1/nio/Heap-X-Buffer.java.template @@ -0,0 +1,601 @@ +/* + * Copyright (c) 2000, 2013, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +package java.nio; + + +/** +#if[rw] + * A read/write Heap$Type$Buffer. +#else[rw] + * A read-only Heap$Type$Buffer. This class extends the corresponding + * read/write class, overriding the mutation methods to throw a {@link + * ReadOnlyBufferException} and overriding the view-buffer methods to return an + * instance of this class rather than of the superclass. +#end[rw] + */ + +class Heap$Type$Buffer$RW$ + extends {#if[ro]?Heap}$Type$Buffer +{ + + // For speed these fields are actually declared in X-Buffer; + // these declarations are here as documentation + /* +#if[rw] + protected final $type$[] hb; + protected final int offset; +#end[rw] + */ + + Heap$Type$Buffer$RW$(int cap, int lim) { // package-private +#if[rw] + super(-1, 0, lim, cap, new $type$[cap], 0); + /* + hb = new $type$[cap]; + offset = 0; + */ +#else[rw] + super(cap, lim); + this.isReadOnly = true; +#end[rw] + } + + Heap$Type$Buffer$RW$($type$[] buf, int off, int len) { // package-private +#if[rw] + super(-1, off, off + len, buf.length, buf, 0); + /* + hb = buf; + offset = 0; + */ +#else[rw] + super(buf, off, len); + this.isReadOnly = true; +#end[rw] + } + + protected Heap$Type$Buffer$RW$($type$[] buf, + int mark, int pos, int lim, int cap, + int off) + { +#if[rw] + super(mark, pos, lim, cap, buf, off); + /* + hb = buf; + offset = off; + */ +#else[rw] + super(buf, mark, pos, lim, cap, off); + this.isReadOnly = true; +#end[rw] + } + + public $Type$Buffer slice() { + return new Heap$Type$Buffer$RW$(hb, + -1, + 0, + this.remaining(), + this.remaining(), + this.position() + offset); + } + + public $Type$Buffer duplicate() { + return new Heap$Type$Buffer$RW$(hb, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + offset); + } + + public $Type$Buffer asReadOnlyBuffer() { +#if[rw] + return new Heap$Type$BufferR(hb, + this.markValue(), + this.position(), + this.limit(), + this.capacity(), + offset); +#else[rw] + return duplicate(); +#end[rw] + } + +#if[rw] + + protected int ix(int i) { + return i + offset; + } + + public $type$ get() { + return hb[ix(nextGetIndex())]; + } + + public $type$ get(int i) { + return hb[ix(checkIndex(i))]; + } + +#if[streamableType] + $type$ getUnchecked(int i) { + return hb[ix(i)]; + } +#end[streamableType] + + public $Type$Buffer get($type$[] dst, int offset, int length) { + checkBounds(offset, length, dst.length); + if (length > remaining()) + throw new BufferUnderflowException(); + System.arraycopy(hb, ix(position()), dst, offset, length); + position(position() + length); + return this; + } + + public boolean isDirect() { + return false; + } + +#end[rw] + + public boolean isReadOnly() { + return {#if[rw]?false:true}; + } + + public $Type$Buffer put($type$ x) { +#if[rw] + hb[ix(nextPutIndex())] = x; + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put(int i, $type$ x) { +#if[rw] + hb[ix(checkIndex(i))] = x; + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put($type$[] src, int offset, int length) { +#if[rw] + checkBounds(offset, length, src.length); + if (length > remaining()) + throw new BufferOverflowException(); + System.arraycopy(src, offset, hb, ix(position()), length); + position(position() + length); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer put($Type$Buffer src) { +#if[rw] + if (src instanceof Heap$Type$Buffer) { + if (src == this) + throw new IllegalArgumentException(); + Heap$Type$Buffer sb = (Heap$Type$Buffer)src; + int n = sb.remaining(); + if (n > remaining()) + throw new BufferOverflowException(); + System.arraycopy(sb.hb, sb.ix(sb.position()), + hb, ix(position()), n); + sb.position(sb.position() + n); + position(position() + n); + } else if (src.isDirect()) { + int n = src.remaining(); + if (n > remaining()) + throw new BufferOverflowException(); + src.get(hb, ix(position()), n); + position(position() + n); + } else { + super.put(src); + } + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer compact() { +#if[rw] + System.arraycopy(hb, ix(position()), hb, ix(0), remaining()); + position(remaining()); + limit(capacity()); + discardMark(); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + + +#if[byte] + + byte _get(int i) { // package-private + return hb[i]; + } + + void _put(int i, byte b) { // package-private +#if[rw] + hb[i] = b; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + // char + +#if[rw] + + public char getChar() { + return Bits.getChar(this, ix(nextGetIndex(2)), bigEndian); + } + + public char getChar(int i) { + return Bits.getChar(this, ix(checkIndex(i, 2)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putChar(char x) { +#if[rw] + Bits.putChar(this, ix(nextPutIndex(2)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putChar(int i, char x) { +#if[rw] + Bits.putChar(this, ix(checkIndex(i, 2)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public CharBuffer asCharBuffer() { + int size = this.remaining() >> 1; + int off = offset + position(); + return (bigEndian + ? (CharBuffer)(new ByteBufferAsCharBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (CharBuffer)(new ByteBufferAsCharBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + + // short + +#if[rw] + + public short getShort() { + return Bits.getShort(this, ix(nextGetIndex(2)), bigEndian); + } + + public short getShort(int i) { + return Bits.getShort(this, ix(checkIndex(i, 2)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putShort(short x) { +#if[rw] + Bits.putShort(this, ix(nextPutIndex(2)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putShort(int i, short x) { +#if[rw] + Bits.putShort(this, ix(checkIndex(i, 2)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public ShortBuffer asShortBuffer() { + int size = this.remaining() >> 1; + int off = offset + position(); + return (bigEndian + ? (ShortBuffer)(new ByteBufferAsShortBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (ShortBuffer)(new ByteBufferAsShortBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + + // int + +#if[rw] + + public int getInt() { + return Bits.getInt(this, ix(nextGetIndex(4)), bigEndian); + } + + public int getInt(int i) { + return Bits.getInt(this, ix(checkIndex(i, 4)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putInt(int x) { +#if[rw] + Bits.putInt(this, ix(nextPutIndex(4)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putInt(int i, int x) { +#if[rw] + Bits.putInt(this, ix(checkIndex(i, 4)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public IntBuffer asIntBuffer() { + int size = this.remaining() >> 2; + int off = offset + position(); + return (bigEndian + ? (IntBuffer)(new ByteBufferAsIntBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (IntBuffer)(new ByteBufferAsIntBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + + // long + +#if[rw] + + public long getLong() { + return Bits.getLong(this, ix(nextGetIndex(8)), bigEndian); + } + + public long getLong(int i) { + return Bits.getLong(this, ix(checkIndex(i, 8)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putLong(long x) { +#if[rw] + Bits.putLong(this, ix(nextPutIndex(8)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putLong(int i, long x) { +#if[rw] + Bits.putLong(this, ix(checkIndex(i, 8)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public LongBuffer asLongBuffer() { + int size = this.remaining() >> 3; + int off = offset + position(); + return (bigEndian + ? (LongBuffer)(new ByteBufferAsLongBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (LongBuffer)(new ByteBufferAsLongBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + + // float + +#if[rw] + + public float getFloat() { + return Bits.getFloat(this, ix(nextGetIndex(4)), bigEndian); + } + + public float getFloat(int i) { + return Bits.getFloat(this, ix(checkIndex(i, 4)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putFloat(float x) { +#if[rw] + Bits.putFloat(this, ix(nextPutIndex(4)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putFloat(int i, float x) { +#if[rw] + Bits.putFloat(this, ix(checkIndex(i, 4)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public FloatBuffer asFloatBuffer() { + int size = this.remaining() >> 2; + int off = offset + position(); + return (bigEndian + ? (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + + // double + +#if[rw] + + public double getDouble() { + return Bits.getDouble(this, ix(nextGetIndex(8)), bigEndian); + } + + public double getDouble(int i) { + return Bits.getDouble(this, ix(checkIndex(i, 8)), bigEndian); + } + +#end[rw] + + public $Type$Buffer putDouble(double x) { +#if[rw] + Bits.putDouble(this, ix(nextPutIndex(8)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public $Type$Buffer putDouble(int i, double x) { +#if[rw] + Bits.putDouble(this, ix(checkIndex(i, 8)), x, bigEndian); + return this; +#else[rw] + throw new ReadOnlyBufferException(); +#end[rw] + } + + public DoubleBuffer asDoubleBuffer() { + int size = this.remaining() >> 3; + int off = offset + position(); + return (bigEndian + ? (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$B(this, + -1, + 0, + size, + size, + off)) + : (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$L(this, + -1, + 0, + size, + size, + off))); + } + + +#end[byte] + + +#if[char] + + String toString(int start, int end) { // package-private + try { + return new String(hb, start + offset, end - start); + } catch (StringIndexOutOfBoundsException x) { + throw new IndexOutOfBoundsException(); + } + } + + + // --- Methods to support CharSequence --- + + public CharBuffer subSequence(int start, int end) { + if ((start < 0) + || (end > length()) + || (start > end)) + throw new IndexOutOfBoundsException(); + int pos = position(); + return new HeapCharBuffer$RW$(hb, + -1, + pos + start, + pos + end, + capacity(), + offset); + } + +#end[char] + + +#if[!byte] + + public ByteOrder order() { + return ByteOrder.nativeOrder(); + } + +#end[!byte] + +} diff --git a/out/production/classes1/nio/X-Buffer-bin.java.template b/out/production/classes1/nio/X-Buffer-bin.java.template new file mode 100644 index 0000000..340a497 --- /dev/null +++ b/out/production/classes1/nio/X-Buffer-bin.java.template @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2000, 2002, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +class XXX { + +#begin + + /** + * Relative get method for reading $a$ $type$ value. + * + *

Reads the next $nbytes$ bytes at this buffer's current position, + * composing them into $a$ $type$ value according to the current byte order, + * and then increments the position by $nbytes$.

+ * + * @return The $type$ value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than $nbytes$ bytes + * remaining in this buffer + */ + public abstract $type$ get$Type$(); + + /** + * Relative put method for writing $a$ $type$ + * value  (optional operation). + * + *

Writes $nbytes$ bytes containing the given $type$ value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by $nbytes$.

+ * + * @param value + * The $type$ value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than $nbytes$ bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer put$Type$($type$ value); + + /** + * Absolute get method for reading $a$ $type$ value. + * + *

Reads $nbytes$ bytes at the given index, composing them into a + * $type$ value according to the current byte order.

+ * + * @param index + * The index from which the bytes will be read + * + * @return The $type$ value at the given index + * + * @throws IndexOutOfBoundsException + * If index is negative + * or not smaller than the buffer's limit, + * minus $nbytesButOne$ + */ + public abstract $type$ get$Type$(int index); + + /** + * Absolute put method for writing $a$ $type$ + * value  (optional operation). + * + *

Writes $nbytes$ bytes containing the given $type$ value, in the + * current byte order, into this buffer at the given index.

+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The $type$ value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If index is negative + * or not smaller than the buffer's limit, + * minus $nbytesButOne$ + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer put$Type$(int index, $type$ value); + + /** + * Creates a view of this byte buffer as $a$ $type$ buffer. + * + *

The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *

The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * $nbytes$, and its mark will be undefined. The new buffer will be direct + * if, and only if, this buffer is direct, and it will be read-only if, and + * only if, this buffer is read-only.

+ * + * @return A new $type$ buffer + */ + public abstract $Type$Buffer as$Type$Buffer(); + +#end + +} diff --git a/out/production/classes1/nio/X-Buffer.java.template b/out/production/classes1/nio/X-Buffer.java.template new file mode 100644 index 0000000..af9eca1 --- /dev/null +++ b/out/production/classes1/nio/X-Buffer.java.template @@ -0,0 +1,1503 @@ +/* + * Copyright (c) 2000, 2013, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +package java.nio; + +#if[char] +import java.io.IOException; +#end[char] +#if[streamableType] +import java.util.Spliterator; +import java.util.stream.StreamSupport; +import java.util.stream.$Streamtype$Stream; +#end[streamableType] + +/** + * $A$ $type$ buffer. + * + *

This class defines {#if[byte]?six:four} categories of operations upon + * $type$ buffers: + * + *

    + * + *

  • Absolute and relative {@link #get() get} and + * {@link #put($type$) put} methods that read and write + * single $type$s;

    • + * + *

  • Relative {@link #get($type$[]) bulk get} + * methods that transfer contiguous sequences of $type$s from this buffer + * into an array; {#if[!byte]?and}

    • + * + *

  • Relative {@link #put($type$[]) bulk put} + * methods that transfer contiguous sequences of $type$s from $a$ + * $type$ array{#if[char]?, a string,} or some other $type$ + * buffer into this buffer;{#if[!byte]? and}

    • + * +#if[byte] + * + *

  • Absolute and relative {@link #getChar() get} + * and {@link #putChar(char) put} methods that read and + * write values of other primitive types, translating them to and from + * sequences of bytes in a particular byte order;

    • + * + *

  • Methods for creating view buffers, + * which allow a byte buffer to be viewed as a buffer containing values of + * some other primitive type; and

    • + * +#end[byte] + * + *

  • Methods for {@link #compact compacting}, {@link + * #duplicate duplicating}, and {@link #slice slicing} + * $a$ $type$ buffer.

    • + * + *
+ * + *

$Type$ buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * +#if[byte] + * + * content, or by {@link #wrap($type$[]) wrapping} an + * existing $type$ array {#if[char]?or string} into a buffer. + * +#else[byte] + * + * content, by {@link #wrap($type$[]) wrapping} an existing + * $type$ array {#if[char]?or string} into a buffer, or by creating a + * view of an existing byte buffer. + * +#end[byte] + * +#if[byte] + * + * + *

Direct vs. non-direct buffers

+ * + *

A byte buffer is either direct or non-direct. Given a + * direct byte buffer, the Java virtual machine will make a best effort to + * perform native I/O operations directly upon it. That is, it will attempt to + * avoid copying the buffer's content to (or from) an intermediate buffer + * before (or after) each invocation of one of the underlying operating + * system's native I/O operations. + * + *

A direct byte buffer may be created by invoking the {@link + * #allocateDirect(int) allocateDirect} factory method of this class. The + * buffers returned by this method typically have somewhat higher allocation + * and deallocation costs than non-direct buffers. The contents of direct + * buffers may reside outside of the normal garbage-collected heap, and so + * their impact upon the memory footprint of an application might not be + * obvious. It is therefore recommended that direct buffers be allocated + * primarily for large, long-lived buffers that are subject to the underlying + * system's native I/O operations. In general it is best to allocate direct + * buffers only when they yield a measureable gain in program performance. + * + *

A direct byte buffer may also be created by {@link + * java.nio.channels.FileChannel#map mapping} a region of a file + * directly into memory. An implementation of the Java platform may optionally + * support the creation of direct byte buffers from native code via JNI. If an + * instance of one of these kinds of buffers refers to an inaccessible region + * of memory then an attempt to access that region will not change the buffer's + * content and will cause an unspecified exception to be thrown either at the + * time of the access or at some later time. + * + *

Whether a byte buffer is direct or non-direct may be determined by + * invoking its {@link #isDirect isDirect} method. This method is provided so + * that explicit buffer management can be done in performance-critical code. + * + * + * + *

Access to binary data

+ * + *

This class defines methods for reading and writing values of all other + * primitive types, except boolean. Primitive values are translated + * to (or from) sequences of bytes according to the buffer's current byte + * order, which may be retrieved and modified via the {@link #order order} + * methods. Specific byte orders are represented by instances of the {@link + * ByteOrder} class. The initial order of a byte buffer is always {@link + * ByteOrder#BIG_ENDIAN BIG_ENDIAN}. + * + *

For access to heterogeneous binary data, that is, sequences of values of + * different types, this class defines a family of absolute and relative + * get and put methods for each type. For 32-bit floating-point + * values, for example, this class defines: + * + * 

+ * float  {@link #getFloat()}
+ * float  {@link #getFloat(int) getFloat(int index)}
+ *  void  {@link #putFloat(float) putFloat(float f)}
+ *  void  {@link #putFloat(int,float) putFloat(int index, float f)}
+ * + *

Corresponding methods are defined for the types char, + * short, int, long, and double. The index + * parameters of the absolute get and put methods are in terms of + * bytes rather than of the type being read or written. + * + * + * + *

For access to homogeneous binary data, that is, sequences of values of + * the same type, this class defines methods that can create views of a + * given byte buffer. A view buffer is simply another buffer whose + * content is backed by the byte buffer. Changes to the byte buffer's content + * will be visible in the view buffer, and vice versa; the two buffers' + * position, limit, and mark values are independent. The {@link + * #asFloatBuffer() asFloatBuffer} method, for example, creates an instance of + * the {@link FloatBuffer} class that is backed by the byte buffer upon which + * the method is invoked. Corresponding view-creation methods are defined for + * the types char, short, int, long, and + * double. + * + *

View buffers have three important advantages over the families of + * type-specific get and put methods described above: + * + *

    + * + *

  • A view buffer is indexed not in terms of bytes but rather in terms + * of the type-specific size of its values;

    • + * + *

  • A view buffer provides relative bulk get and put + * methods that can transfer contiguous sequences of values between a buffer + * and an array or some other buffer of the same type; and

    • + * + *

  • A view buffer is potentially much more efficient because it will + * be direct if, and only if, its backing byte buffer is direct.

    • + * + *
+ * + *

The byte order of a view buffer is fixed to be that of its byte buffer + * at the time that the view is created.

+ * +#end[byte] +* +#if[!byte] + * + *

Like a byte buffer, $a$ $type$ buffer is either direct or non-direct. A + * $type$ buffer created via the wrap methods of this class will + * be non-direct. $A$ $type$ buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * $a$ $type$ buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.

+ * +#end[!byte] +* +#if[char] + * + *

This class implements the {@link CharSequence} interface so that + * character buffers may be used wherever character sequences are accepted, for + * example in the regular-expression package {@link java.util.regex}. + *

+ * +#end[char] + * +#if[byte] + *

Invocation chaining

+#end[byte] + * + *

Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * +#if[byte] + * + * The sequence of statements + * + * 

+ * bb.putInt(0xCAFEBABE);
+ * bb.putShort(3);
+ * bb.putShort(45);
+ * + * can, for example, be replaced by the single statement + * + * 
+ * bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
+ * +#end[byte] +#if[char] + * + * The sequence of statements + * + * 
+ * cb.put("text/");
+ * cb.put(subtype);
+ * cb.put("; charset=");
+ * cb.put(enc);
+ * + * can, for example, be replaced by the single statement + * + * 
+ * cb.put("text/").put(subtype).put("; charset=").put(enc);
+ * +#end[char] + * + * + * @author Mark Reinhold + * @author JSR-51 Expert Group + * @since 1.4 + */ + +public abstract class $Type$Buffer + extends Buffer + implements Comparable<$Type$Buffer>{#if[char]?, Appendable, CharSequence, Readable} +{ + + // These fields are declared here rather than in Heap-X-Buffer in order to + // reduce the number of virtual method invocations needed to access these + // values, which is especially costly when coding small buffers. + // + final $type$[] hb; // Non-null only for heap buffers + final int offset; + boolean isReadOnly; // Valid only for heap buffers + + // Creates a new buffer with the given mark, position, limit, capacity, + // backing array, and array offset + // + $Type$Buffer(int mark, int pos, int lim, int cap, // package-private + $type$[] hb, int offset) + { + super(mark, pos, lim, cap); + this.hb = hb; + this.offset = offset; + } + + // Creates a new buffer with the given mark, position, limit, and capacity + // + $Type$Buffer(int mark, int pos, int lim, int cap) { // package-private + this(mark, pos, lim, cap, null, 0); + } + +#if[byte] + + /** + * Allocates a new direct $type$ buffer. + * + *

The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, and each of its elements will be + * initialized to zero. Whether or not it has a + * {@link #hasArray backing array} is unspecified. + * + * @param capacity + * The new buffer's capacity, in $type$s + * + * @return The new $type$ buffer + * + * @throws IllegalArgumentException + * If the capacity is a negative integer + */ + public static $Type$Buffer allocateDirect(int capacity) { + return new Direct$Type$Buffer(capacity); + } + +#end[byte] + + /** + * Allocates a new $type$ buffer. + * + *

The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, and each of its elements will be + * initialized to zero. It will have a {@link #array backing array}, + * and its {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in $type$s + * + * @return The new $type$ buffer + * + * @throws IllegalArgumentException + * If the capacity is a negative integer + */ + public static $Type$Buffer allocate(int capacity) { + if (capacity < 0) + throw new IllegalArgumentException(); + return new Heap$Type$Buffer(capacity, capacity); + } + + /** + * Wraps $a$ $type$ array into a buffer. + * + *

The new buffer will be backed by the given $type$ array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * array.length, its position will be offset, its limit + * will be offset + length, and its mark will be undefined. Its + * {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.

+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than array.length. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * array.length - offset. + * The new buffer's limit will be set to offset + length. + * + * @return The new $type$ buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the offset and length + * parameters do not hold + */ + public static $Type$Buffer wrap($type$[] array, + int offset, int length) + { + try { + return new Heap$Type$Buffer(array, offset, length); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps $a$ $type$ array into a buffer. + * + *

The new buffer will be backed by the given $type$ array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * array.length, its position will be zero, and its mark will be + * undefined. Its {@link #array backing array} will be the + * given array, and its {@link #arrayOffset array offset>} will + * be zero.

+ * + * @param array + * The array that will back this buffer + * + * @return The new $type$ buffer + */ + public static $Type$Buffer wrap($type$[] array) { + return wrap(array, 0, array.length); + } + +#if[char] + + /** + * Attempts to read characters into the specified character buffer. + * The buffer is used as a repository of characters as-is: the only + * changes made are the results of a put operation. No flipping or + * rewinding of the buffer is performed. + * + * @param target the buffer to read characters into + * @return The number of characters added to the buffer, or + * -1 if this source of characters is at its end + * @throws IOException if an I/O error occurs + * @throws NullPointerException if target is null + * @throws ReadOnlyBufferException if target is a read only buffer + * @since 1.5 + */ + public int read(CharBuffer target) throws IOException { + // Determine the number of bytes n that can be transferred + int targetRemaining = target.remaining(); + int remaining = remaining(); + if (remaining == 0) + return -1; + int n = Math.min(remaining, targetRemaining); + int limit = limit(); + // Set source limit to prevent target overflow + if (targetRemaining < remaining) + limit(position() + n); + try { + if (n > 0) + target.put(this); + } finally { + limit(limit); // restore real limit + } + return n; + } + + /** + * Wraps a character sequence into a buffer. + * + *

The content of the new, read-only buffer will be the content of the + * given character sequence. The buffer's capacity will be + * csq.length(), its position will be start, its limit + * will be end, and its mark will be undefined.

+ * + * @param csq + * The character sequence from which the new character buffer is to + * be created + * + * @param start + * The index of the first character to be used; + * must be non-negative and no larger than csq.length(). + * The new buffer's position will be set to this value. + * + * @param end + * The index of the character following the last character to be + * used; must be no smaller than start and no larger + * than csq.length(). + * The new buffer's limit will be set to this value. + * + * @return The new character buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the start and end + * parameters do not hold + */ + public static CharBuffer wrap(CharSequence csq, int start, int end) { + try { + return new StringCharBuffer(csq, start, end); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a character sequence into a buffer. + * + *

The content of the new, read-only buffer will be the content of the + * given character sequence. The new buffer's capacity and limit will be + * csq.length(), its position will be zero, and its mark will be + * undefined.

+ * + * @param csq + * The character sequence from which the new character buffer is to + * be created + * + * @return The new character buffer + */ + public static CharBuffer wrap(CharSequence csq) { + return wrap(csq, 0, csq.length()); + } + +#end[char] + + /** + * Creates a new $type$ buffer whose content is a shared subsequence of + * this buffer's content. + * + *

The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *

The new buffer's position will be zero, its capacity and its limit + * will be the number of $type$s remaining in this buffer, and its mark + * will be undefined. The new buffer will be direct if, and only if, this + * buffer is direct, and it will be read-only if, and only if, this buffer + * is read-only.

+ * + * @return The new $type$ buffer + */ + public abstract $Type$Buffer slice(); + + /** + * Creates a new $type$ buffer that shares this buffer's content. + * + *

The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *

The new buffer's capacity, limit, position, and mark values will be + * identical to those of this buffer. The new buffer will be direct if, + * and only if, this buffer is direct, and it will be read-only if, and + * only if, this buffer is read-only.

+ * + * @return The new $type$ buffer + */ + public abstract $Type$Buffer duplicate(); + + /** + * Creates a new, read-only $type$ buffer that shares this buffer's + * content. + * + *

The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *

The new buffer's capacity, limit, position, and mark values will be + * identical to those of this buffer. + * + *

If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.

+ * + * @return The new, read-only $type$ buffer + */ + public abstract $Type$Buffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the $type$ at this buffer's + * current position, and then increments the position. + * + * @return The $type$ at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract $type$ get(); + + /** + * Relative put method  (optional operation). + * + *

Writes the given $type$ into this buffer at the current + * position, and then increments the position.

+ * + * @param $x$ + * The $type$ to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract $Type$Buffer put($type$ $x$); + + /** + * Absolute get method. Reads the $type$ at the given + * index. + * + * @param index + * The index from which the $type$ will be read + * + * @return The $type$ at the given index + * + * @throws IndexOutOfBoundsException + * If index is negative + * or not smaller than the buffer's limit + */ + public abstract $type$ get(int index); + +#if[streamableType] + /** + * Absolute get method. Reads the $type$ at the given + * index without any validation of the index. + * + * @param index + * The index from which the $type$ will be read + * + * @return The $type$ at the given index + */ + abstract $type$ getUnchecked(int index); // package-private +#end[streamableType] + + /** + * Absolute put method  (optional operation). + * + *

Writes the given $type$ into this buffer at the given + * index.

+ * + * @param index + * The index at which the $type$ will be written + * + * @param $x$ + * The $type$ value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If index is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract $Type$Buffer put(int index, $type$ $x$); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *

This method transfers $type$s from this buffer into the given + * destination array. If there are fewer $type$s remaining in the + * buffer than are required to satisfy the request, that is, if + * length > remaining(), then no + * $type$s are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *

Otherwise, this method copies length $type$s from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by length. + * + *

In other words, an invocation of this method of the form + * src.get(dst, off, len) has exactly the same effect as + * the loop + * + * 

{@code
+     *     for (int i = off; i < off + len; i++)
+     *         dst[i] = src.get():
+     * }
+ * + * except that it first checks that there are sufficient $type$s in + * this buffer and it is potentially much more efficient. + * + * @param dst + * The array into which $type$s are to be written + * + * @param offset + * The offset within the array of the first $type$ to be + * written; must be non-negative and no larger than + * dst.length + * + * @param length + * The maximum number of $type$s to be written to the given + * array; must be non-negative and no larger than + * dst.length - offset + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than length $type$s + * remaining in this buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the offset and length + * parameters do not hold + */ + public $Type$Buffer get($type$[] dst, int offset, int length) { + checkBounds(offset, length, dst.length); + if (length > remaining()) + throw new BufferUnderflowException(); + int end = offset + length; + for (int i = offset; i < end; i++) + dst[i] = get(); + return this; + } + + /** + * Relative bulk get method. + * + *

This method transfers $type$s from this buffer into the given + * destination array. An invocation of this method of the form + * src.get(a) behaves in exactly the same way as the invocation + * + * 

+     *     src.get(a, 0, a.length)
+ * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than length $type$s + * remaining in this buffer + */ + public $Type$Buffer get($type$[] dst) { + return get(dst, 0, dst.length); + } + + + // -- Bulk put operations -- + + /** + * Relative bulk put method  (optional operation). + * + *

This method transfers the $type$s remaining in the given source + * buffer into this buffer. If there are more $type$s remaining in the + * source buffer than in this buffer, that is, if + * src.remaining() > remaining(), + * then no $type$s are transferred and a {@link + * BufferOverflowException} is thrown. + * + *

Otherwise, this method copies + * n = src.remaining() $type$s from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *

In other words, an invocation of this method of the form + * dst.put(src) has exactly the same effect as the loop + * + * 

+     *     while (src.hasRemaining())
+     *         dst.put(src.get());
+ * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. + * + * @param src + * The source buffer from which $type$s are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining $type$s in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public $Type$Buffer put($Type$Buffer src) { + if (src == this) + throw new IllegalArgumentException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + int n = src.remaining(); + if (n > remaining()) + throw new BufferOverflowException(); + for (int i = 0; i < n; i++) + put(src.get()); + return this; + } + + /** + * Relative bulk put method  (optional operation). + * + *

This method transfers $type$s into this buffer from the given + * source array. If there are more $type$s to be copied from the array + * than remain in this buffer, that is, if + * length > remaining(), then no + * $type$s are transferred and a {@link BufferOverflowException} is + * thrown. + * + *

Otherwise, this method copies length $type$s from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by length. + * + *

In other words, an invocation of this method of the form + * dst.put(src, off, len) has exactly the same effect as + * the loop + * + * 

{@code
+     *     for (int i = off; i < off + len; i++)
+     *         dst.put(a[i]);
+     * }
+ * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. + * + * @param src + * The array from which $type$s are to be read + * + * @param offset + * The offset within the array of the first $type$ to be read; + * must be non-negative and no larger than array.length + * + * @param length + * The number of $type$s to be read from the given array; + * must be non-negative and no larger than + * array.length - offset + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the offset and length + * parameters do not hold + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public $Type$Buffer put($type$[] src, int offset, int length) { + checkBounds(offset, length, src.length); + if (length > remaining()) + throw new BufferOverflowException(); + int end = offset + length; + for (int i = offset; i < end; i++) + this.put(src[i]); + return this; + } + + /** + * Relative bulk put method  (optional operation). + * + *

This method transfers the entire content of the given source + * $type$ array into this buffer. An invocation of this method of the + * form dst.put(a) behaves in exactly the same way as the + * invocation + * + * 

+     *     dst.put(a, 0, a.length)
+ * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final $Type$Buffer put($type$[] src) { + return put(src, 0, src.length); + } + +#if[char] + + /** + * Relative bulk put method  (optional operation). + * + *

This method transfers $type$s from the given string into this + * buffer. If there are more $type$s to be copied from the string than + * remain in this buffer, that is, if + * end - start > remaining(), + * then no $type$s are transferred and a {@link + * BufferOverflowException} is thrown. + * + *

Otherwise, this method copies + * n = end - start $type$s + * from the given string into this buffer, starting at the given + * start index and at the current position of this buffer. The + * position of this buffer is then incremented by n. + * + *

In other words, an invocation of this method of the form + * dst.put(src, start, end) has exactly the same effect + * as the loop + * + * 

{@code
+     *     for (int i = start; i < end; i++)
+     *         dst.put(src.charAt(i));
+     * }
+ * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. + * + * @param src + * The string from which $type$s are to be read + * + * @param start + * The offset within the string of the first $type$ to be read; + * must be non-negative and no larger than + * string.length() + * + * @param end + * The offset within the string of the last $type$ to be read, + * plus one; must be non-negative and no larger than + * string.length() + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the start and end + * parameters do not hold + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public $Type$Buffer put(String src, int start, int end) { + checkBounds(start, end - start, src.length()); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + if (end - start > remaining()) + throw new BufferOverflowException(); + for (int i = start; i < end; i++) + this.put(src.charAt(i)); + return this; + } + + /** + * Relative bulk put method  (optional operation). + * + *

This method transfers the entire content of the given source string + * into this buffer. An invocation of this method of the form + * dst.put(s) behaves in exactly the same way as the invocation + * + * 

+     *     dst.put(s, 0, s.length())
+ * + * @param src + * The source string + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final $Type$Buffer put(String src) { + return put(src, 0, src.length()); + } + +#end[char] + + + // -- Other stuff -- + + /** + * Tells whether or not this buffer is backed by an accessible $type$ + * array. + * + *

If this method returns true then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *

+ * + * @return true if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the $type$ array that backs this + * buffer  (optional operation). + * + *

Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *

Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.

+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final $type$[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer  (optional operation). + * + *

If this buffer is backed by an array then buffer position p + * corresponds to array index p + arrayOffset(). + * + *

Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.

+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + /** + * Compacts this buffer  (optional operation). + * + *

The $type$s between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * $type$ at index p = position() is copied + * to index zero, the $type$ at index p + 1 is copied + * to index one, and so forth until the $type$ at index + * limit() - 1 is copied to index + * n = limit() - 1 - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *

The buffer's position is set to the number of $type$s copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.

+ * +#if[byte] + * + *

Invoke this method after writing data from a buffer in case the + * write was incomplete. The following loop, for example, copies bytes + * from one channel to another via the buffer buf: + * + * 

{@code
+     *   buf.clear();          // Prepare buffer for use
+     *   while (in.read(buf) >= 0 || buf.position != 0) {
+     *       buf.flip();
+     *       out.write(buf);
+     *       buf.compact();    // In case of partial write
+     *   }
+     * }
+ * +#end[byte] + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract $Type$Buffer compact(); + + /** + * Tells whether or not this $type$ buffer is direct. + * + * @return true if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + +#if[!char] + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + sb.append(getClass().getName()); + sb.append("[pos="); + sb.append(position()); + sb.append(" lim="); + sb.append(limit()); + sb.append(" cap="); + sb.append(capacity()); + sb.append("]"); + return sb.toString(); + } + +#end[!char] + + + // ## Should really use unchecked accessors here for speed + + /** + * Returns the current hash code of this buffer. + * + *

The hash code of a $type$ buffer depends only upon its remaining + * elements; that is, upon the elements from position() up to, and + * including, the element at limit() - 1. + * + *

Because buffer hash codes are content-dependent, it is inadvisable + * to use buffers as keys in hash maps or similar data structures unless it + * is known that their contents will not change.

+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) +#if[int] + h = 31 * h + get(i); +#else[int] + h = 31 * h + (int)get(i); +#end[int] + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *

Two $type$ buffers are equal if, and only if, + * + *

    + * + *

  1. They have the same element type,

    2. + * + *

  2. They have the same number of remaining elements, and + *

    3. + * + *

  3. The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. +#if[floatingPointType] + * This method considers two $type$ elements {@code a} and {@code b} + * to be equal if + * {@code (a == b) || ($Fulltype$.isNaN(a) && $Fulltype$.isNaN(b))}. + * The values {@code -0.0} and {@code +0.0} are considered to be + * equal, unlike {@link $Fulltype$#equals(Object)}. +#end[floatingPointType] + *

    4. + * + *
+ * + *

A $type$ buffer is not equal to any other type of object.

+ * + * @param ob The object to which this buffer is to be compared + * + * @return true if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(Object ob) { + if (this == ob) + return true; + if (!(ob instanceof $Type$Buffer)) + return false; + $Type$Buffer that = ($Type$Buffer)ob; + if (this.remaining() != that.remaining()) + return false; + int p = this.position(); + for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) + if (!equals(this.get(i), that.get(j))) + return false; + return true; + } + + private static boolean equals($type$ x, $type$ y) { +#if[floatingPointType] + return (x == y) || ($Fulltype$.isNaN(x) && $Fulltype$.isNaN(y)); +#else[floatingPointType] + return x == y; +#end[floatingPointType] + } + + /** + * Compares this buffer to another. + * + *

Two $type$ buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. +#if[floatingPointType] + * Pairs of {@code $type$} elements are compared as if by invoking + * {@link $Fulltype$#compare($type$,$type$)}, except that + * {@code -0.0} and {@code 0.0} are considered to be equal. + * {@code $Fulltype$.NaN} is considered by this method to be equal + * to itself and greater than all other {@code $type$} values + * (including {@code $Fulltype$.POSITIVE_INFINITY}). +#else[floatingPointType] + * Pairs of {@code $type$} elements are compared as if by invoking + * {@link $Fulltype$#compare($type$,$type$)}. +#end[floatingPointType] + * + *

A $type$ buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo($Type$Buffer that) { + int n = this.position() + Math.min(this.remaining(), that.remaining()); + for (int i = this.position(), j = that.position(); i < n; i++, j++) { + int cmp = compare(this.get(i), that.get(j)); + if (cmp != 0) + return cmp; + } + return this.remaining() - that.remaining(); + } + + private static int compare($type$ x, $type$ y) { +#if[floatingPointType] + return ((x < y) ? -1 : + (x > y) ? +1 : + (x == y) ? 0 : + $Fulltype$.isNaN(x) ? ($Fulltype$.isNaN(y) ? 0 : +1) : -1); +#else[floatingPointType] + return $Fulltype$.compare(x, y); +#end[floatingPointType] + } + + // -- Other char stuff -- + +#if[char] + + /** + * Returns a string containing the characters in this buffer. + * + *

The first character of the resulting string will be the character at + * this buffer's position, while the last character will be the character + * at index limit() - 1. Invoking this method does not + * change the buffer's position.

+ * + * @return The specified string + */ + public String toString() { + return toString(position(), limit()); + } + + abstract String toString(int start, int end); // package-private + + + // --- Methods to support CharSequence --- + + /** + * Returns the length of this character buffer. + * + *

When viewed as a character sequence, the length of a character + * buffer is simply the number of characters between the position + * (inclusive) and the limit (exclusive); that is, it is equivalent to + * remaining().

+ * + * @return The length of this character buffer + */ + public final int length() { + return remaining(); + } + + /** + * Reads the character at the given index relative to the current + * position. + * + * @param index + * The index of the character to be read, relative to the position; + * must be non-negative and smaller than remaining() + * + * @return The character at index + * position() + index + * + * @throws IndexOutOfBoundsException + * If the preconditions on index do not hold + */ + public final char charAt(int index) { + return get(position() + checkIndex(index, 1)); + } + + /** + * Creates a new character buffer that represents the specified subsequence + * of this buffer, relative to the current position. + * + *

The new buffer will share this buffer's content; that is, if the + * content of this buffer is mutable then modifications to one buffer will + * cause the other to be modified. The new buffer's capacity will be that + * of this buffer, its position will be + * position() + start, and its limit will be + * position() + end. The new buffer will be + * direct if, and only if, this buffer is direct, and it will be read-only + * if, and only if, this buffer is read-only.

+ * + * @param start + * The index, relative to the current position, of the first + * character in the subsequence; must be non-negative and no larger + * than remaining() + * + * @param end + * The index, relative to the current position, of the character + * following the last character in the subsequence; must be no + * smaller than start and no larger than + * remaining() + * + * @return The new character buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on start and end + * do not hold + */ + public abstract CharBuffer subSequence(int start, int end); + + + // --- Methods to support Appendable --- + + /** + * Appends the specified character sequence to this + * buffer  (optional operation). + * + *

An invocation of this method of the form dst.append(csq) + * behaves in exactly the same way as the invocation + * + * 

+     *     dst.put(csq.toString())
+ * + *

Depending on the specification of toString for the + * character sequence csq, the entire sequence may not be + * appended. For instance, invoking the {@link $Type$Buffer#toString() + * toString} method of a character buffer will return a subsequence whose + * content depends upon the buffer's position and limit. + * + * @param csq + * The character sequence to append. If csq is + * null, then the four characters "null" are + * appended to this character buffer. + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public $Type$Buffer append(CharSequence csq) { + if (csq == null) + return put("null"); + else + return put(csq.toString()); + } + + /** + * Appends a subsequence of the specified character sequence to this + * buffer  (optional operation). + * + *

An invocation of this method of the form dst.append(csq, start, + * end) when csq is not null, behaves in exactly the + * same way as the invocation + * + * 

+     *     dst.put(csq.subSequence(start, end).toString())
+ * + * @param csq + * The character sequence from which a subsequence will be + * appended. If csq is null, then characters + * will be appended as if csq contained the four + * characters "null". + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws IndexOutOfBoundsException + * If start or end are negative, start + * is greater than end, or end is greater than + * csq.length() + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public $Type$Buffer append(CharSequence csq, int start, int end) { + CharSequence cs = (csq == null ? "null" : csq); + return put(cs.subSequence(start, end).toString()); + } + + /** + * Appends the specified $type$ to this + * buffer  (optional operation). + * + *

An invocation of this method of the form dst.append($x$) + * behaves in exactly the same way as the invocation + * + * 

+     *     dst.put($x$)
+ * + * @param $x$ + * The 16-bit $type$ to append + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public $Type$Buffer append($type$ $x$) { + return put($x$); + } + +#end[char] + + + // -- Other byte stuff: Access to binary data -- + +#if[!byte] + + /** + * Retrieves this buffer's byte order. + * + *

The byte order of $a$ $type$ buffer created by allocation or by + * wrapping an existing $type$ array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of $a$ $type$ buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.

+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + +#end[!byte] + +#if[byte] + + boolean bigEndian // package-private + = true; + boolean nativeByteOrder // package-private + = (Bits.byteOrder() == ByteOrder.BIG_ENDIAN); + + /** + * Retrieves this buffer's byte order. + * + *

The byte order is used when reading or writing multibyte values, and + * when creating buffers that are views of this byte buffer. The order of + * a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN + * BIG_ENDIAN}.

+ * + * @return This buffer's byte order + */ + public final ByteOrder order() { + return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN; + } + + /** + * Modifies this buffer's byte order. + * + * @param bo + * The new byte order, + * either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN} + * or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN} + * + * @return This buffer + */ + public final $Type$Buffer order(ByteOrder bo) { + bigEndian = (bo == ByteOrder.BIG_ENDIAN); + nativeByteOrder = + (bigEndian == (Bits.byteOrder() == ByteOrder.BIG_ENDIAN)); + return this; + } + + // Unchecked accessors, for use by ByteBufferAs-X-Buffer classes + // + abstract byte _get(int i); // package-private + abstract void _put(int i, byte b); // package-private + + // #BIN + // + // Binary-data access methods for short, char, int, long, float, + // and double will be inserted here + +#end[byte] + +#if[streamableType] + +#if[char] + @Override +#end[char] + public $Streamtype$Stream $type$s() { + return StreamSupport.$streamtype$Stream(() -> new $Type$BufferSpliterator(this), + Buffer.SPLITERATOR_CHARACTERISTICS, false); + } + +#end[streamableType] + +} diff --git a/out/production/classes1/nio/channels/exceptions b/out/production/classes1/nio/channels/exceptions new file mode 100644 index 0000000..3f75fb3 --- /dev/null +++ b/out/production/classes1/nio/channels/exceptions @@ -0,0 +1,194 @@ +# +# Copyright (c) 2000, 2009, Oracle and/or its affiliates. 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. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Generated exception classes for java.nio.channels + +SINCE=1.4 +PACKAGE=java.nio.channels +# This year should only change if the generated source is modified. +COPYRIGHT_YEARS="2000, 2007," + + +SUPER=java.io.IOException + +gen ClosedChannelException " + * Checked exception thrown when an attempt is made to invoke or complete an + * I/O operation upon channel that is closed, or at least closed to that + * operation. That this exception is thrown does not necessarily imply that + * the channel is completely closed. A socket channel whose write half has + * been shut down, for example, may still be open for reading." \ + 882777185433553857L + +gen FileLockInterruptionException " + * Checked exception received by a thread when another thread interrupts it + * while it is waiting to acquire a file lock. Before this exception is thrown + * the interrupt status of the previously-blocked thread will have been set." \ + 7104080643653532383L + + +SUPER=ClosedChannelException + +gen AsynchronousCloseException " + * Checked exception received by a thread when another thread closes the + * channel or the part of the channel upon which it is blocked in an I/O + * operation." \ + 6891178312432313966L + + +SUPER=AsynchronousCloseException + +gen ClosedByInterruptException " + * Checked exception received by a thread when another thread interrupts it + * while it is blocked in an I/O operation upon a channel. Before this + * exception is thrown the channel will have been closed and the interrupt + * status of the previously-blocked thread will have been set." \ + -4488191543534286750L + + +SUPER=IllegalArgumentException + +gen IllegalSelectorException " + * Unchecked exception thrown when an attempt is made to register a channel + * with a selector that was not created by the provider that created the + * channel." \ + -8406323347253320987L + +gen UnresolvedAddressException " + * Unchecked exception thrown when an attempt is made to invoke a network + * operation upon an unresolved socket address." \ + 6136959093620794148L + +gen UnsupportedAddressTypeException " + * Unchecked exception thrown when an attempt is made to bind or connect + * to a socket address of a type that is not supported." \ + -2964323842829700493L + + +SUPER=IllegalStateException + +gen AlreadyConnectedException " + * Unchecked exception thrown when an attempt is made to connect a {@link + * SocketChannel} that is already connected." \ + -7331895245053773357L + +gen ConnectionPendingException " + * Unchecked exception thrown when an attempt is made to connect a {@link + * SocketChannel} for which a non-blocking connection operation is already in + * progress." \ + 2008393366501760879L + +gen ClosedSelectorException " + * Unchecked exception thrown when an attempt is made to invoke an I/O + * operation upon a closed selector." \ + 6466297122317847835L + +gen CancelledKeyException " + * Unchecked exception thrown when an attempt is made to use + * a selection key that is no longer valid." \ + -8438032138028814268L + +gen IllegalBlockingModeException " + * Unchecked exception thrown when a blocking-mode-specific operation + * is invoked upon a channel in the incorrect blocking mode." \ + -3335774961855590474L + +gen NoConnectionPendingException " + * Unchecked exception thrown when the {@link SocketChannel#finishConnect + * finishConnect} method of a {@link SocketChannel} is invoked without first + * successfully invoking its {@link SocketChannel#connect connect} method." \ + -8296561183633134743L + +gen NonReadableChannelException " + * Unchecked exception thrown when an attempt is made to read + * from a channel that was not originally opened for reading." \ + -3200915679294993514L + +gen NonWritableChannelException " + * Unchecked exception thrown when an attempt is made to write + * to a channel that was not originally opened for writing." \ + -7071230488279011621L + +gen NotYetBoundException " + * Unchecked exception thrown when an attempt is made to invoke an I/O + * operation upon a server socket channel that is not yet bound." \ + 4640999303950202242L + +gen NotYetConnectedException " + * Unchecked exception thrown when an attempt is made to invoke an I/O + * operation upon a socket channel that is not yet connected." \ + 4697316551909513464L + +gen OverlappingFileLockException " + * Unchecked exception thrown when an attempt is made to acquire a lock on a + * region of a file that overlaps a region already locked by the same Java + * virtual machine, or when another thread is already waiting to lock an + * overlapping region of the same file." \ + 2047812138163068433L + + +SINCE=1.7 + +SUPER=java.io.IOException + +gen InterruptedByTimeoutException " + * Checked exception received by a thread when a timeout elapses before an + * asynchronous operation completes." \ + -4268008601014042947L + +SUPER=IllegalArgumentException + +gen IllegalChannelGroupException " + * Unchecked exception thrown when an attempt is made to open a channel + * in a group that was not created by the same provider. " \ + -2495041211157744253L + + +SUPER=IllegalStateException + +gen AlreadyBoundException " + * Unchecked exception thrown when an attempt is made to bind the socket a + * network oriented channel that is already bound." \ + 6796072983322737592L + +gen AcceptPendingException " + * Unchecked exception thrown when an attempt is made to initiate an accept + * operation on a channel and a previous accept operation has not completed." \ + 2721339977965416421L + +gen ReadPendingException " + * Unchecked exception thrown when an attempt is made to read from an + * asynchronous socket channel and a previous read has not completed." \ + 1986315242191227217L + +gen WritePendingException " + * Unchecked exception thrown when an attempt is made to write to an + * asynchronous socket channel and a previous write has not completed." \ + 7031871839266032276L + +gen ShutdownChannelGroupException " + * Unchecked exception thrown when an attempt is made to construct a channel in + * a group that is shutdown or the completion handler for an I/O operation + * cannot be invoked because the channel group has terminated." \ + -3903801676350154157L diff --git a/out/production/classes1/nio/channels/spi/package.html b/out/production/classes1/nio/channels/spi/package.html new file mode 100644 index 0000000..a6f8cbf --- /dev/null +++ b/out/production/classes1/nio/channels/spi/package.html @@ -0,0 +1,45 @@ + + + + + + +Service-provider classes for the {@link java.nio.channels} package. + +

Only developers who are defining new selector providers or asynchronous +channel providers should need to make direct use of this package.

+ +

Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a {@link +java.lang.NullPointerException NullPointerException} to be thrown. + + +@since 1.4 +@author Mark Reinhold +@author JSR-51 Expert Group + + + diff --git a/out/production/classes1/nio/charset/Charset-X-Coder.java.template b/out/production/classes1/nio/charset/Charset-X-Coder.java.template new file mode 100644 index 0000000..f5e50a5 --- /dev/null +++ b/out/production/classes1/nio/charset/Charset-X-Coder.java.template @@ -0,0 +1,996 @@ +/* + * Copyright (c) 2000, 2013, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#warn This file is preprocessed before being compiled + +package java.nio.charset; + +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.BufferOverflowException; +import java.nio.BufferUnderflowException; +import java.lang.ref.WeakReference; +import java.nio.charset.CoderMalfunctionError; // javadoc +import java.util.Arrays; + + +/** + * An engine that can transform a sequence of $itypesPhrase$ into a sequence of + * $otypesPhrase$. + * + * + * + *

The input $itype$ sequence is provided in a $itype$ buffer or a series + * of such buffers. The output $otype$ sequence is written to a $otype$ buffer + * or a series of such buffers. $A$ $coder$ should always be used by making + * the following sequence of method invocations, hereinafter referred to as $a$ + * $coding$ operation: + * + *

    + * + *

  1. Reset the $coder$ via the {@link #reset reset} method, unless it + * has not been used before;

    2. + * + *

  2. Invoke the {@link #$code$ $code$} method zero or more times, as + * long as additional input may be available, passing false for the + * endOfInput argument and filling the input buffer and flushing the + * output buffer between invocations;

    3. + * + *

  3. Invoke the {@link #$code$ $code$} method one final time, passing + * true for the endOfInput argument; and then

    4. + * + *

  4. Invoke the {@link #flush flush} method so that the $coder$ can + * flush any internal state to the output buffer.

    5. + * + *
+ * + * Each invocation of the {@link #$code$ $code$} method will $code$ as many + * $itype$s as possible from the input buffer, writing the resulting $otype$s + * to the output buffer. The {@link #$code$ $code$} method returns when more + * input is required, when there is not enough room in the output buffer, or + * when $a$ $coding$ error has occurred. In each case a {@link CoderResult} + * object is returned to describe the reason for termination. An invoker can + * examine this object and fill the input buffer, flush the output buffer, or + * attempt to recover from $a$ $coding$ error, as appropriate, and try again. + * + * + * + *

There are two general types of $coding$ errors. If the input $itype$ + * sequence is $notLegal$ then the input is considered malformed. If + * the input $itype$ sequence is legal but cannot be mapped to a valid + * $outSequence$ then an unmappable character has been encountered. + * + * + * + *

How $a$ $coding$ error is handled depends upon the action requested for + * that type of error, which is described by an instance of the {@link + * CodingErrorAction} class. The possible error actions are to {@linkplain + * CodingErrorAction#IGNORE ignore} the erroneous input, {@linkplain + * CodingErrorAction#REPORT report} the error to the invoker via + * the returned {@link CoderResult} object, or {@linkplain CodingErrorAction#REPLACE + * replace} the erroneous input with the current value of the + * replacement $replTypeName$. The replacement + * +#if[encoder] + * is initially set to the $coder$'s default replacement, which often + * (but not always) has the initial value $defaultReplName$; +#end[encoder] +#if[decoder] + * has the initial value $defaultReplName$; +#end[decoder] + * + * its value may be changed via the {@link #replaceWith($replFQType$) + * replaceWith} method. + * + *

The default action for malformed-input and unmappable-character errors + * is to {@linkplain CodingErrorAction#REPORT report} them. The + * malformed-input error action may be changed via the {@link + * #onMalformedInput(CodingErrorAction) onMalformedInput} method; the + * unmappable-character action may be changed via the {@link + * #onUnmappableCharacter(CodingErrorAction) onUnmappableCharacter} method. + * + *

This class is designed to handle many of the details of the $coding$ + * process, including the implementation of error actions. $A$ $coder$ for a + * specific charset, which is a concrete subclass of this class, need only + * implement the abstract {@link #$code$Loop $code$Loop} method, which + * encapsulates the basic $coding$ loop. A subclass that maintains internal + * state should, additionally, override the {@link #implFlush implFlush} and + * {@link #implReset implReset} methods. + * + *

Instances of this class are not safe for use by multiple concurrent + * threads.

+ * + * + * @author Mark Reinhold + * @author JSR-51 Expert Group + * @since 1.4 + * + * @see ByteBuffer + * @see CharBuffer + * @see Charset + * @see Charset$OtherCoder$ + */ + +public abstract class Charset$Coder$ { + + private final Charset charset; + private final float average$ItypesPerOtype$; + private final float max$ItypesPerOtype$; + + private $replType$ replacement; + private CodingErrorAction malformedInputAction + = CodingErrorAction.REPORT; + private CodingErrorAction unmappableCharacterAction + = CodingErrorAction.REPORT; + + // Internal states + // + private static final int ST_RESET = 0; + private static final int ST_CODING = 1; + private static final int ST_END = 2; + private static final int ST_FLUSHED = 3; + + private int state = ST_RESET; + + private static String stateNames[] + = { "RESET", "CODING", "CODING_END", "FLUSHED" }; + + + /** + * Initializes a new $coder$. The new $coder$ will have the given + * $otypes-per-itype$ and replacement values. + * + * @param cs + * The charset that created this $coder$ + * + * @param average$ItypesPerOtype$ + * A positive float value indicating the expected number of + * $otype$s that will be produced for each input $itype$ + * + * @param max$ItypesPerOtype$ + * A positive float value indicating the maximum number of + * $otype$s that will be produced for each input $itype$ + * + * @param replacement + * The initial replacement; must not be null, must have + * non-zero length, must not be longer than max$ItypesPerOtype$, + * and must be {@linkplain #isLegalReplacement legal} + * + * @throws IllegalArgumentException + * If the preconditions on the parameters do not hold + */ + {#if[encoder]?protected:private} + Charset$Coder$(Charset cs, + float average$ItypesPerOtype$, + float max$ItypesPerOtype$, + $replType$ replacement) + { + this.charset = cs; + if (average$ItypesPerOtype$ <= 0.0f) + throw new IllegalArgumentException("Non-positive " + + "average$ItypesPerOtype$"); + if (max$ItypesPerOtype$ <= 0.0f) + throw new IllegalArgumentException("Non-positive " + + "max$ItypesPerOtype$"); + if (!Charset.atBugLevel("1.4")) { + if (average$ItypesPerOtype$ > max$ItypesPerOtype$) + throw new IllegalArgumentException("average$ItypesPerOtype$" + + " exceeds " + + "max$ItypesPerOtype$"); + } + this.replacement = replacement; + this.average$ItypesPerOtype$ = average$ItypesPerOtype$; + this.max$ItypesPerOtype$ = max$ItypesPerOtype$; + replaceWith(replacement); + } + + /** + * Initializes a new $coder$. The new $coder$ will have the given + * $otypes-per-itype$ values and its replacement will be the + * $replTypeName$ $defaultReplName$. + * + * @param cs + * The charset that created this $coder$ + * + * @param average$ItypesPerOtype$ + * A positive float value indicating the expected number of + * $otype$s that will be produced for each input $itype$ + * + * @param max$ItypesPerOtype$ + * A positive float value indicating the maximum number of + * $otype$s that will be produced for each input $itype$ + * + * @throws IllegalArgumentException + * If the preconditions on the parameters do not hold + */ + protected Charset$Coder$(Charset cs, + float average$ItypesPerOtype$, + float max$ItypesPerOtype$) + { + this(cs, + average$ItypesPerOtype$, max$ItypesPerOtype$, + $defaultRepl$); + } + + /** + * Returns the charset that created this $coder$. + * + * @return This $coder$'s charset + */ + public final Charset charset() { + return charset; + } + + /** + * Returns this $coder$'s replacement value. + * + * @return This $coder$'s current replacement, + * which is never null and is never empty + */ + public final $replType$ replacement() { +#if[decoder] + return replacement; +#end[decoder] +#if[encoder] + return Arrays.copyOf(replacement, replacement.$replLength$); +#end[encoder] + } + + /** + * Changes this $coder$'s replacement value. + * + *

This method invokes the {@link #implReplaceWith implReplaceWith} + * method, passing the new replacement, after checking that the new + * replacement is acceptable.

+ * + * @param newReplacement The replacement value + * +#if[decoder] + * The new replacement; must not be null + * and must have non-zero length +#end[decoder] +#if[encoder] + * The new replacement; must not be null, must have + * non-zero length, must not be longer than the value returned by + * the {@link #max$ItypesPerOtype$() max$ItypesPerOtype$} method, and + * must be {@link #isLegalReplacement legal} +#end[encoder] + * + * @return This $coder$ + * + * @throws IllegalArgumentException + * If the preconditions on the parameter do not hold + */ + public final Charset$Coder$ replaceWith($replType$ newReplacement) { + if (newReplacement == null) + throw new IllegalArgumentException("Null replacement"); + int len = newReplacement.$replLength$; + if (len == 0) + throw new IllegalArgumentException("Empty replacement"); + if (len > max$ItypesPerOtype$) + throw new IllegalArgumentException("Replacement too long"); +#if[decoder] + this.replacement = newReplacement; +#end[decoder] +#if[encoder] + if (!isLegalReplacement(newReplacement)) + throw new IllegalArgumentException("Illegal replacement"); + this.replacement = Arrays.copyOf(newReplacement, newReplacement.$replLength$); +#end[encoder] + implReplaceWith(this.replacement); + return this; + } + + /** + * Reports a change to this $coder$'s replacement value. + * + *

The default implementation of this method does nothing. This method + * should be overridden by $coder$s that require notification of changes to + * the replacement.

+ * + * @param newReplacement The replacement value + */ + protected void implReplaceWith($replType$ newReplacement) { + } + +#if[encoder] + + private WeakReference cachedDecoder = null; + + /** + * Tells whether or not the given byte array is a legal replacement value + * for this encoder. + * + *

A replacement is legal if, and only if, it is a legal sequence of + * bytes in this encoder's charset; that is, it must be possible to decode + * the replacement into one or more sixteen-bit Unicode characters. + * + *

The default implementation of this method is not very efficient; it + * should generally be overridden to improve performance.

+ * + * @param repl The byte array to be tested + * + * @return true if, and only if, the given byte array + * is a legal replacement value for this encoder + */ + public boolean isLegalReplacement(byte[] repl) { + WeakReference wr = cachedDecoder; + CharsetDecoder dec = null; + if ((wr == null) || ((dec = wr.get()) == null)) { + dec = charset().newDecoder(); + dec.onMalformedInput(CodingErrorAction.REPORT); + dec.onUnmappableCharacter(CodingErrorAction.REPORT); + cachedDecoder = new WeakReference(dec); + } else { + dec.reset(); + } + ByteBuffer bb = ByteBuffer.wrap(repl); + CharBuffer cb = CharBuffer.allocate((int)(bb.remaining() + * dec.maxCharsPerByte())); + CoderResult cr = dec.decode(bb, cb, true); + return !cr.isError(); + } + +#end[encoder] + + /** + * Returns this $coder$'s current action for malformed-input errors. + * + * @return The current malformed-input action, which is never null + */ + public CodingErrorAction malformedInputAction() { + return malformedInputAction; + } + + /** + * Changes this $coder$'s action for malformed-input errors. + * + *

This method invokes the {@link #implOnMalformedInput + * implOnMalformedInput} method, passing the new action.

+ * + * @param newAction The new action; must not be null + * + * @return This $coder$ + * + * @throws IllegalArgumentException + * If the precondition on the parameter does not hold + */ + public final Charset$Coder$ onMalformedInput(CodingErrorAction newAction) { + if (newAction == null) + throw new IllegalArgumentException("Null action"); + malformedInputAction = newAction; + implOnMalformedInput(newAction); + return this; + } + + /** + * Reports a change to this $coder$'s malformed-input action. + * + *

The default implementation of this method does nothing. This method + * should be overridden by $coder$s that require notification of changes to + * the malformed-input action.

+ * + * @param newAction The new action + */ + protected void implOnMalformedInput(CodingErrorAction newAction) { } + + /** + * Returns this $coder$'s current action for unmappable-character errors. + * + * @return The current unmappable-character action, which is never + * null + */ + public CodingErrorAction unmappableCharacterAction() { + return unmappableCharacterAction; + } + + /** + * Changes this $coder$'s action for unmappable-character errors. + * + *

This method invokes the {@link #implOnUnmappableCharacter + * implOnUnmappableCharacter} method, passing the new action.

+ * + * @param newAction The new action; must not be null + * + * @return This $coder$ + * + * @throws IllegalArgumentException + * If the precondition on the parameter does not hold + */ + public final Charset$Coder$ onUnmappableCharacter(CodingErrorAction + newAction) + { + if (newAction == null) + throw new IllegalArgumentException("Null action"); + unmappableCharacterAction = newAction; + implOnUnmappableCharacter(newAction); + return this; + } + + /** + * Reports a change to this $coder$'s unmappable-character action. + * + *

The default implementation of this method does nothing. This method + * should be overridden by $coder$s that require notification of changes to + * the unmappable-character action.

+ * + * @param newAction The new action + */ + protected void implOnUnmappableCharacter(CodingErrorAction newAction) { } + + /** + * Returns the average number of $otype$s that will be produced for each + * $itype$ of input. This heuristic value may be used to estimate the size + * of the output buffer required for a given input sequence. + * + * @return The average number of $otype$s produced + * per $itype$ of input + */ + public final float average$ItypesPerOtype$() { + return average$ItypesPerOtype$; + } + + /** + * Returns the maximum number of $otype$s that will be produced for each + * $itype$ of input. This value may be used to compute the worst-case size + * of the output buffer required for a given input sequence. + * + * @return The maximum number of $otype$s that will be produced per + * $itype$ of input + */ + public final float max$ItypesPerOtype$() { + return max$ItypesPerOtype$; + } + + /** + * $Code$s as many $itype$s as possible from the given input buffer, + * writing the results to the given output buffer. + * + *

The buffers are read from, and written to, starting at their current + * positions. At most {@link Buffer#remaining in.remaining()} $itype$s + * will be read and at most {@link Buffer#remaining out.remaining()} + * $otype$s will be written. The buffers' positions will be advanced to + * reflect the $itype$s read and the $otype$s written, but their marks and + * limits will not be modified. + * + *

In addition to reading $itype$s from the input buffer and writing + * $otype$s to the output buffer, this method returns a {@link CoderResult} + * object to describe its reason for termination: + * + *

    + * + *

  • {@link CoderResult#UNDERFLOW} indicates that as much of the + * input buffer as possible has been $code$d. If there is no further + * input then the invoker can proceed to the next step of the + * $coding$ operation. Otherwise this method + * should be invoked again with further input.

    • + * + *

  • {@link CoderResult#OVERFLOW} indicates that there is + * insufficient space in the output buffer to $code$ any more $itype$s. + * This method should be invoked again with an output buffer that has + * more {@linkplain Buffer#remaining remaining} $otype$s. This is + * typically done by draining any $code$d $otype$s from the output + * buffer.

    • + * + *

  • A {@linkplain CoderResult#malformedForLength + * malformed-input} result indicates that a malformed-input + * error has been detected. The malformed $itype$s begin at the input + * buffer's (possibly incremented) position; the number of malformed + * $itype$s may be determined by invoking the result object's {@link + * CoderResult#length() length} method. This case applies only if the + * {@linkplain #onMalformedInput malformed action} of this $coder$ + * is {@link CodingErrorAction#REPORT}; otherwise the malformed input + * will be ignored or replaced, as requested.

    • + * + *

  • An {@linkplain CoderResult#unmappableForLength + * unmappable-character} result indicates that an + * unmappable-character error has been detected. The $itype$s that + * $code$ the unmappable character begin at the input buffer's (possibly + * incremented) position; the number of such $itype$s may be determined + * by invoking the result object's {@link CoderResult#length() length} + * method. This case applies only if the {@linkplain #onUnmappableCharacter + * unmappable action} of this $coder$ is {@link + * CodingErrorAction#REPORT}; otherwise the unmappable character will be + * ignored or replaced, as requested.

    • + * + *
+ * + * In any case, if this method is to be reinvoked in the same $coding$ + * operation then care should be taken to preserve any $itype$s remaining + * in the input buffer so that they are available to the next invocation. + * + *

The endOfInput parameter advises this method as to whether + * the invoker can provide further input beyond that contained in the given + * input buffer. If there is a possibility of providing additional input + * then the invoker should pass false for this parameter; if there + * is no possibility of providing further input then the invoker should + * pass true. It is not erroneous, and in fact it is quite + * common, to pass false in one invocation and later discover that + * no further input was actually available. It is critical, however, that + * the final invocation of this method in a sequence of invocations always + * pass true so that any remaining un$code$d input will be treated + * as being malformed. + * + *

This method works by invoking the {@link #$code$Loop $code$Loop} + * method, interpreting its results, handling error conditions, and + * reinvoking it as necessary.

+ * + * + * @param in + * The input $itype$ buffer + * + * @param out + * The output $otype$ buffer + * + * @param endOfInput + * true if, and only if, the invoker can provide no + * additional input $itype$s beyond those in the given buffer + * + * @return A coder-result object describing the reason for termination + * + * @throws IllegalStateException + * If $a$ $coding$ operation is already in progress and the previous + * step was an invocation neither of the {@link #reset reset} + * method, nor of this method with a value of false for + * the endOfInput parameter, nor of this method with a + * value of true for the endOfInput parameter + * but a return value indicating an incomplete $coding$ operation + * + * @throws CoderMalfunctionError + * If an invocation of the $code$Loop method threw + * an unexpected exception + */ + public final CoderResult $code$($Itype$Buffer in, $Otype$Buffer out, + boolean endOfInput) + { + int newState = endOfInput ? ST_END : ST_CODING; + if ((state != ST_RESET) && (state != ST_CODING) + && !(endOfInput && (state == ST_END))) + throwIllegalStateException(state, newState); + state = newState; + + for (;;) { + + CoderResult cr; + try { + cr = $code$Loop(in, out); + } catch (BufferUnderflowException x) { + throw new CoderMalfunctionError(x); + } catch (BufferOverflowException x) { + throw new CoderMalfunctionError(x); + } + + if (cr.isOverflow()) + return cr; + + if (cr.isUnderflow()) { + if (endOfInput && in.hasRemaining()) { + cr = CoderResult.malformedForLength(in.remaining()); + // Fall through to malformed-input case + } else { + return cr; + } + } + + CodingErrorAction action = null; + if (cr.isMalformed()) + action = malformedInputAction; + else if (cr.isUnmappable()) + action = unmappableCharacterAction; + else + assert false : cr.toString(); + + if (action == CodingErrorAction.REPORT) + return cr; + + if (action == CodingErrorAction.REPLACE) { + if (out.remaining() < replacement.$replLength$) + return CoderResult.OVERFLOW; + out.put(replacement); + } + + if ((action == CodingErrorAction.IGNORE) + || (action == CodingErrorAction.REPLACE)) { + // Skip erroneous input either way + in.position(in.position() + cr.length()); + continue; + } + + assert false; + } + + } + + /** + * Flushes this $coder$. + * + *

Some $coder$s maintain internal state and may need to write some + * final $otype$s to the output buffer once the overall input sequence has + * been read. + * + *

Any additional output is written to the output buffer beginning at + * its current position. At most {@link Buffer#remaining out.remaining()} + * $otype$s will be written. The buffer's position will be advanced + * appropriately, but its mark and limit will not be modified. + * + *

If this method completes successfully then it returns {@link + * CoderResult#UNDERFLOW}. If there is insufficient room in the output + * buffer then it returns {@link CoderResult#OVERFLOW}. If this happens + * then this method must be invoked again, with an output buffer that has + * more room, in order to complete the current $coding$ + * operation. + * + *

If this $coder$ has already been flushed then invoking this method + * has no effect. + * + *

This method invokes the {@link #implFlush implFlush} method to + * perform the actual flushing operation.

+ * + * @param out + * The output $otype$ buffer + * + * @return A coder-result object, either {@link CoderResult#UNDERFLOW} or + * {@link CoderResult#OVERFLOW} + * + * @throws IllegalStateException + * If the previous step of the current $coding$ operation was an + * invocation neither of the {@link #flush flush} method nor of + * the three-argument {@link + * #$code$($Itype$Buffer,$Otype$Buffer,boolean) $code$} method + * with a value of true for the endOfInput + * parameter + */ + public final CoderResult flush($Otype$Buffer out) { + if (state == ST_END) { + CoderResult cr = implFlush(out); + if (cr.isUnderflow()) + state = ST_FLUSHED; + return cr; + } + + if (state != ST_FLUSHED) + throwIllegalStateException(state, ST_FLUSHED); + + return CoderResult.UNDERFLOW; // Already flushed + } + + /** + * Flushes this $coder$. + * + *

The default implementation of this method does nothing, and always + * returns {@link CoderResult#UNDERFLOW}. This method should be overridden + * by $coder$s that may need to write final $otype$s to the output buffer + * once the entire input sequence has been read.

+ * + * @param out + * The output $otype$ buffer + * + * @return A coder-result object, either {@link CoderResult#UNDERFLOW} or + * {@link CoderResult#OVERFLOW} + */ + protected CoderResult implFlush($Otype$Buffer out) { + return CoderResult.UNDERFLOW; + } + + /** + * Resets this $coder$, clearing any internal state. + * + *

This method resets charset-independent state and also invokes the + * {@link #implReset() implReset} method in order to perform any + * charset-specific reset actions.

+ * + * @return This $coder$ + * + */ + public final Charset$Coder$ reset() { + implReset(); + state = ST_RESET; + return this; + } + + /** + * Resets this $coder$, clearing any charset-specific internal state. + * + *

The default implementation of this method does nothing. This method + * should be overridden by $coder$s that maintain internal state.

+ */ + protected void implReset() { } + + /** + * $Code$s one or more $itype$s into one or more $otype$s. + * + *

This method encapsulates the basic $coding$ loop, $coding$ as many + * $itype$s as possible until it either runs out of input, runs out of room + * in the output buffer, or encounters $a$ $coding$ error. This method is + * invoked by the {@link #$code$ $code$} method, which handles result + * interpretation and error recovery. + * + *

The buffers are read from, and written to, starting at their current + * positions. At most {@link Buffer#remaining in.remaining()} $itype$s + * will be read, and at most {@link Buffer#remaining out.remaining()} + * $otype$s will be written. The buffers' positions will be advanced to + * reflect the $itype$s read and the $otype$s written, but their marks and + * limits will not be modified. + * + *

This method returns a {@link CoderResult} object to describe its + * reason for termination, in the same manner as the {@link #$code$ $code$} + * method. Most implementations of this method will handle $coding$ errors + * by returning an appropriate result object for interpretation by the + * {@link #$code$ $code$} method. An optimized implementation may instead + * examine the relevant error action and implement that action itself. + * + *

An implementation of this method may perform arbitrary lookahead by + * returning {@link CoderResult#UNDERFLOW} until it receives sufficient + * input.

+ * + * @param in + * The input $itype$ buffer + * + * @param out + * The output $otype$ buffer + * + * @return A coder-result object describing the reason for termination + */ + protected abstract CoderResult $code$Loop($Itype$Buffer in, + $Otype$Buffer out); + + /** + * Convenience method that $code$s the remaining content of a single input + * $itype$ buffer into a newly-allocated $otype$ buffer. + * + *

This method implements an entire $coding$ + * operation; that is, it resets this $coder$, then it $code$s the + * $itype$s in the given $itype$ buffer, and finally it flushes this + * $coder$. This method should therefore not be invoked if $a$ $coding$ + * operation is already in progress.

+ * + * @param in + * The input $itype$ buffer + * + * @return A newly-allocated $otype$ buffer containing the result of the + * $coding$ operation. The buffer's position will be zero and its + * limit will follow the last $otype$ written. + * + * @throws IllegalStateException + * If $a$ $coding$ operation is already in progress + * + * @throws MalformedInputException + * If the $itype$ sequence starting at the input buffer's current + * position is $notLegal$ and the current malformed-input action + * is {@link CodingErrorAction#REPORT} + * + * @throws UnmappableCharacterException + * If the $itype$ sequence starting at the input buffer's current + * position cannot be mapped to an equivalent $otype$ sequence and + * the current unmappable-character action is {@link + * CodingErrorAction#REPORT} + */ + public final $Otype$Buffer $code$($Itype$Buffer in) + throws CharacterCodingException + { + int n = (int)(in.remaining() * average$ItypesPerOtype$()); + $Otype$Buffer out = $Otype$Buffer.allocate(n); + + if ((n == 0) && (in.remaining() == 0)) + return out; + reset(); + for (;;) { + CoderResult cr = in.hasRemaining() ? + $code$(in, out, true) : CoderResult.UNDERFLOW; + if (cr.isUnderflow()) + cr = flush(out); + + if (cr.isUnderflow()) + break; + if (cr.isOverflow()) { + n = 2*n + 1; // Ensure progress; n might be 0! + $Otype$Buffer o = $Otype$Buffer.allocate(n); + out.flip(); + o.put(out); + out = o; + continue; + } + cr.throwException(); + } + out.flip(); + return out; + } + +#if[decoder] + + /** + * Tells whether or not this decoder implements an auto-detecting charset. + * + *

The default implementation of this method always returns + * false; it should be overridden by auto-detecting decoders to + * return true.

+ * + * @return true if, and only if, this decoder implements an + * auto-detecting charset + */ + public boolean isAutoDetecting() { + return false; + } + + /** + * Tells whether or not this decoder has yet detected a + * charset  (optional operation). + * + *

If this decoder implements an auto-detecting charset then at a + * single point during a decoding operation this method may start returning + * true to indicate that a specific charset has been detected in + * the input byte sequence. Once this occurs, the {@link #detectedCharset + * detectedCharset} method may be invoked to retrieve the detected charset. + * + *

That this method returns false does not imply that no bytes + * have yet been decoded. Some auto-detecting decoders are capable of + * decoding some, or even all, of an input byte sequence without fixing on + * a particular charset. + * + *

The default implementation of this method always throws an {@link + * UnsupportedOperationException}; it should be overridden by + * auto-detecting decoders to return true once the input charset + * has been determined.

+ * + * @return true if, and only if, this decoder has detected a + * specific charset + * + * @throws UnsupportedOperationException + * If this decoder does not implement an auto-detecting charset + */ + public boolean isCharsetDetected() { + throw new UnsupportedOperationException(); + } + + /** + * Retrieves the charset that was detected by this + * decoder  (optional operation). + * + *

If this decoder implements an auto-detecting charset then this + * method returns the actual charset once it has been detected. After that + * point, this method returns the same value for the duration of the + * current decoding operation. If not enough input bytes have yet been + * read to determine the actual charset then this method throws an {@link + * IllegalStateException}. + * + *

The default implementation of this method always throws an {@link + * UnsupportedOperationException}; it should be overridden by + * auto-detecting decoders to return the appropriate value.

+ * + * @return The charset detected by this auto-detecting decoder, + * or null if the charset has not yet been determined + * + * @throws IllegalStateException + * If insufficient bytes have been read to determine a charset + * + * @throws UnsupportedOperationException + * If this decoder does not implement an auto-detecting charset + */ + public Charset detectedCharset() { + throw new UnsupportedOperationException(); + } + +#end[decoder] + +#if[encoder] + + private boolean canEncode(CharBuffer cb) { + if (state == ST_FLUSHED) + reset(); + else if (state != ST_RESET) + throwIllegalStateException(state, ST_CODING); + CodingErrorAction ma = malformedInputAction(); + CodingErrorAction ua = unmappableCharacterAction(); + try { + onMalformedInput(CodingErrorAction.REPORT); + onUnmappableCharacter(CodingErrorAction.REPORT); + encode(cb); + } catch (CharacterCodingException x) { + return false; + } finally { + onMalformedInput(ma); + onUnmappableCharacter(ua); + reset(); + } + return true; + } + + /** + * Tells whether or not this encoder can encode the given character. + * + *

This method returns false if the given character is a + * surrogate character; such characters can be interpreted only when they + * are members of a pair consisting of a high surrogate followed by a low + * surrogate. The {@link #canEncode(java.lang.CharSequence) + * canEncode(CharSequence)} method may be used to test whether or not a + * character sequence can be encoded. + * + *

This method may modify this encoder's state; it should therefore not + * be invoked if an encoding operation is already in + * progress. + * + *

The default implementation of this method is not very efficient; it + * should generally be overridden to improve performance.

+ * + * @param c + * The given character + * + * @return true if, and only if, this encoder can encode + * the given character + * + * @throws IllegalStateException + * If $a$ $coding$ operation is already in progress + */ + public boolean canEncode(char c) { + CharBuffer cb = CharBuffer.allocate(1); + cb.put(c); + cb.flip(); + return canEncode(cb); + } + + /** + * Tells whether or not this encoder can encode the given character + * sequence. + * + *

If this method returns false for a particular character + * sequence then more information about why the sequence cannot be encoded + * may be obtained by performing a full encoding + * operation. + * + *

This method may modify this encoder's state; it should therefore not + * be invoked if an encoding operation is already in progress. + * + *

The default implementation of this method is not very efficient; it + * should generally be overridden to improve performance.

+ * + * @param cs + * The given character sequence + * + * @return true if, and only if, this encoder can encode + * the given character without throwing any exceptions and without + * performing any replacements + * + * @throws IllegalStateException + * If $a$ $coding$ operation is already in progress + */ + public boolean canEncode(CharSequence cs) { + CharBuffer cb; + if (cs instanceof CharBuffer) + cb = ((CharBuffer)cs).duplicate(); + else + cb = CharBuffer.wrap(cs.toString()); + return canEncode(cb); + } + +#end[encoder] + + + private void throwIllegalStateException(int from, int to) { + throw new IllegalStateException("Current state = " + stateNames[from] + + ", new state = " + stateNames[to]); + } + +} diff --git a/out/production/classes1/nio/charset/exceptions b/out/production/classes1/nio/charset/exceptions new file mode 100644 index 0000000..22dfa3c --- /dev/null +++ b/out/production/classes1/nio/charset/exceptions @@ -0,0 +1,53 @@ +# +# Copyright (c) 2000, 2007, Oracle and/or its affiliates. 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. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Generated exception classes for java.nio.charset + +SINCE=1.4 +PACKAGE=java.nio.charset +# This year should only change if the generated source is modified. +COPYRIGHT_YEARS="2000, 2007," + +SUPER=java.io.IOException + +gen CharacterCodingException " + * Checked exception thrown when a character encoding + * or decoding error occurs." \ + 8421532232154627783L + + +SUPER=IllegalArgumentException + +gen IllegalCharsetNameException " + * Unchecked exception thrown when a string that is not a + * legal charset name is used as such." \ + 1457525358470002989L \ + String charsetName CharsetName "illegal charset name" + +gen UnsupportedCharsetException " + * Unchecked exception thrown when no support is available + * for a requested charset." \ + 1490765524727386367L \ + String charsetName CharsetName "name of the unsupported charset" diff --git a/out/production/classes1/nio/charset/package.html b/out/production/classes1/nio/charset/package.html new file mode 100644 index 0000000..69b160b --- /dev/null +++ b/out/production/classes1/nio/charset/package.html @@ -0,0 +1,88 @@ + + + + + + + +Defines charsets, decoders, and encoders, for translating between bytes and +Unicode characters. + +
+ + + + + + + + + + + + +

Class name

Description

{@link java.nio.charset.Charset}A named mapping between characters
and bytes
{@link java.nio.charset.CharsetDecoder}Decodes bytes into characters
{@link java.nio.charset.CharsetEncoder}  Encodes characters into bytes
{@link java.nio.charset.CoderResult}  Describes coder results
{@link java.nio.charset.CodingErrorAction}  Describes actions to take when
coding errors are detected
+ +

A charset is named mapping between sequences of sixteen-bit Unicode +characters and sequences of bytes, in the sense defined in RFC 2278. A +decoder is an engine which transforms bytes in a specific charset into +characters, and an encoder is an engine which transforms characters into +bytes. Encoders and decoders operate on byte and character buffers. They are +collectively referred to as coders. + +

The {@link java.nio.charset.Charset} class defines methods for creating +coders for a given charset and for retrieving the various names associated with +a charset. It also defines static methods for testing whether a particular +charset is supported, for locating charset instances by name, and for +constructing a map that contains every charset for which support is available +in the current Java virtual machine. + +

Most users will not use these classes directly; instead they will use the +existing charset-related constructors and methods in the {@link +java.lang.String} class, together with the existing {@link +java.io.InputStreamReader} and {@link java.io.OutputStreamWriter} classes, all +of whose implementations have been reworked to make use of the charset +facilities defined in this package. A small number of changes have been made +to the {@link java.io.InputStreamReader} and {@link java.io.OutputStreamWriter} +classes in order to allow explicit charset objects to be specified in the +construction of instances of those classes. + +

Support for new charsets can be made available via the interface defined in +the {@link java.nio.charset.spi.CharsetProvider} class in the {@link +java.nio.charset.spi} package. + +

Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a {@link +java.lang.NullPointerException NullPointerException} to be thrown. + + +@since 1.4 +@author Mark Reinhold +@author JSR-51 Expert Group + + + diff --git a/out/production/classes1/nio/charset/spi/package.html b/out/production/classes1/nio/charset/spi/package.html new file mode 100644 index 0000000..a7b7ab1 --- /dev/null +++ b/out/production/classes1/nio/charset/spi/package.html @@ -0,0 +1,45 @@ + + + + + + +Service-provider classes for the {@link java.nio.charset} package. + +

Only developers who are defining new charsets should need to make direct +use of this package.

+ +

Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a {@link +java.lang.NullPointerException NullPointerException} to be thrown. + + +@since 1.4 +@author Mark Reinhold +@author JSR-51 Expert Group + + + diff --git a/out/production/classes1/nio/exceptions b/out/production/classes1/nio/exceptions new file mode 100644 index 0000000..062ccc4 --- /dev/null +++ b/out/production/classes1/nio/exceptions @@ -0,0 +1,60 @@ +# +# Copyright (c) 2000, 2007, Oracle and/or its affiliates. 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. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Generated exception classes for java.nio + +SINCE=1.4 +PACKAGE=java.nio +# This year should only change if the generated source is modified. +COPYRIGHT_YEARS="2000, 2007," + + +SUPER=RuntimeException + +gen BufferOverflowException " + * Unchecked exception thrown when a relative put operation reaches + * the target buffer's limit." \ + -5484897634319144535L + +gen BufferUnderflowException " + * Unchecked exception thrown when a relative get operation reaches + * the source buffer's limit." \ + -1713313658691622206L + + +SUPER=IllegalStateException + +gen InvalidMarkException " + * Unchecked exception thrown when an attempt is made to reset a buffer + * when its mark is not defined." \ + 1698329710438510774L + + +SUPER=UnsupportedOperationException + +gen ReadOnlyBufferException " + * Unchecked exception thrown when a content-mutation method such as + * put or compact is invoked upon a read-only buffer." \ + -1210063976496234090L diff --git a/out/production/classes1/nio/package.html b/out/production/classes1/nio/package.html new file mode 100644 index 0000000..eddd611 --- /dev/null +++ b/out/production/classes1/nio/package.html @@ -0,0 +1,139 @@ + + + + + + +Defines buffers, which are containers for data, and provides an overview of the +other NIO packages. + + +

The central abstractions of the NIO APIs are:

+ +
    + +

  • Buffers, which are containers for data; +

    • + +

  • Charsets and their + associated decoders and encoders,
    which translate between + bytes and Unicode characters;

    • + +

  • Channels of + various types, which represent connections
    to entities capable of + performing I/O operations; and

    • + +

  • Selectors and selection keys, which together with
    + selectable channels define a multiplexed, non-blocking
    + I/O     facility.

    • + +
+ +

The java.nio package defines the buffer classes, which are used +throughout the NIO APIs. The charset API is defined in the {@link +java.nio.charset} package, and the channel and selector APIs are defined in the +{@link java.nio.channels} package. Each of these subpackages has its own +service-provider (SPI) subpackage, the contents of which can be used to extend +the platform's default implementations or to construct alternative +implementations. + + + + +

+ + + + + + + + + + + + + + + + + + + + + +

Buffers

Description

{@link java.nio.Buffer}Position, limit, and capacity; +
clear, flip, rewind, and mark/reset
  {@link java.nio.ByteBuffer}Get/put, compact, views; allocate, wrap
    {@link java.nio.MappedByteBuffer}  A byte buffer mapped to a file
  {@link java.nio.CharBuffer}Get/put, compact; allocate, wrap
  {@link java.nio.DoubleBuffer}    ' '
  {@link java.nio.FloatBuffer}    ' '
  {@link java.nio.IntBuffer}    ' '
  {@link java.nio.LongBuffer}    ' '
  {@link java.nio.ShortBuffer}    ' '
{@link java.nio.ByteOrder}Typesafe enumeration for byte orders
+ +

A buffer is a container for a fixed amount of data of a specific +primitive type. In addition to its content a buffer has a position, +which is the index of the next element to be read or written, and a +limit, which is the index of the first element that should not be read +or written. The base {@link java.nio.Buffer} class defines these properties as +well as methods for clearing, flipping, and rewinding, for +marking the current position, and for resetting the position to +the previous mark. + +

There is a buffer class for each non-boolean primitive type. Each class +defines a family of get and put methods for moving data out of +and in to a buffer, methods for compacting, duplicating, and +slicing a buffer, and static methods for allocating a new buffer +as well as for wrapping an existing array into a buffer. + +

Byte buffers are distinguished in that they can be used as the sources and +targets of I/O operations. They also support several features not found in the +other buffer classes: + +

    + +

  • A byte buffer can be allocated as a + direct buffer, in which case the Java virtual machine will make a + best effort to perform native I/O operations directly upon it.

    • + +

  • A byte buffer can be created by {@link + java.nio.channels.FileChannel#map mapping} a region of a + file directly into memory, in which case a few additional file-related + operations defined in the {@link java.nio.MappedByteBuffer} class are + available.

    • + +

  • A byte buffer provides access to its content as either a heterogeneous + or homogeneous sequence of binary data + of any non-boolean primitive type, in either big-endian or little-endian byte order.

    • + +
+ +

Unless otherwise noted, passing a null argument to a constructor +or method in any class or interface in this package will cause a {@link +java.lang.NullPointerException NullPointerException} to be thrown. + +@since 1.4 +@author Mark Reinhold +@author JSR-51 Expert Group + + + diff --git a/out/production/classes1/rmi/activation/package.html b/out/production/classes1/rmi/activation/package.html new file mode 100644 index 0000000..ed4bb79 --- /dev/null +++ b/out/production/classes1/rmi/activation/package.html @@ -0,0 +1,61 @@ + + + + + + +Provides support for RMI Object Activation. A remote +object's reference can be made ``persistent'' and later activated into a +``live'' object using the RMI activation mechanism. + +

Implementations are not required to support the activation +mechanism. If activation is not supported by this implementation, +several specific activation API methods are all required to throw +{@code UnsupportedOperationException}. If activation is supported by this +implementation, these methods must never throw {@code +UnsupportedOperationException}. These methods are denoted by the +presence of an entry for {@code UnsupportedOperationException} in the +Throws section of each method's specification. + + + +@since 1.2 + + diff --git a/out/production/classes1/rmi/dgc/package.html b/out/production/classes1/rmi/dgc/package.html new file mode 100644 index 0000000..a1b63b6 --- /dev/null +++ b/out/production/classes1/rmi/dgc/package.html @@ -0,0 +1,55 @@ + + + + + + +Provides classes and interface for RMI distributed +garbage-collection (DGC). When the RMI server returns an object to +its client (caller of the remote method), it tracks the remote +object's usage in the client. When there are no more references to the +remote object on the client, or if the reference's ``lease'' expires and +not renewed, the server garbage-collects the remote object. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/rmi/package.html b/out/production/classes1/rmi/package.html new file mode 100644 index 0000000..1551d1b --- /dev/null +++ b/out/production/classes1/rmi/package.html @@ -0,0 +1,59 @@ + + + + + + +Provides the RMI package. RMI is Remote Method Invocation. It is a +mechanism that enables an object on one Java virtual machine to invoke +methods on an object in another Java virtual machine. Any object that +can be invoked this way must implement the Remote interface. When such +an object is invoked, its arguments are ``marshalled'' and sent from the +local virtual machine to the remote one, where the arguments are +``unmarshalled.'' When the method terminates, the results are +marshalled from the remote machine and sent to the caller's virtual +machine. If the method invocation results in an exception being +thrown, the exception is indicated to caller. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/rmi/registry/package.html b/out/production/classes1/rmi/registry/package.html new file mode 100644 index 0000000..2451d22 --- /dev/null +++ b/out/production/classes1/rmi/registry/package.html @@ -0,0 +1,57 @@ + + + + + + + +Provides a class and two interfaces for the RMI registry. +A registry is a remote object that maps names to remote objects. A +server registers its remote objects with the registry so that they can +be looked up. When an object wants to invoke a method on a remote +object, it must first lookup the remote object using its name. The +registry returns to the calling object a reference to the remote +object, using which a remote method can be invoked. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/rmi/server/package.html b/out/production/classes1/rmi/server/package.html new file mode 100644 index 0000000..1bfa46d --- /dev/null +++ b/out/production/classes1/rmi/server/package.html @@ -0,0 +1,74 @@ + + + + + + +Provides classes and interfaces for supporting the server +side of RMI. A group of classes are used by the stubs and skeletons +generated by the rmic stub compiler. Another group of classes +implements the RMI Transport protocol and HTTP tunneling. + +

Deprecated: HTTP Tunneling. The HTTP tunneling +mechanism has been deprecated. See {@link java.rmi.server.RMISocketFactory} for +further information. + +

Deprecated: Skeletons and Static Stubs. + +Skeletons and statically generated stubs are deprecated. This +includes the APIs in this package that require the use of skeletons +or static stubs, the runtime support for them, and the use of the +{@code rmic} stub compiler to generate them. Support for skeletons +and static stubs may be removed in a future release of the +platform. Skeletons are unnecessary, as server-side method dispatching +is handled directly by the RMI runtime. Statically generated stubs are +unnecessary, as stubs are generated dynamically using {@link +java.lang.reflect.Proxy Proxy} objects. See {@link +java.rmi.server.UnicastRemoteObject UnicastRemoteObject} for +information about dynamic stub generation. Generation of skeletons and +static stubs was typically performed as part of an application's build +process by calling the {@code rmic} tool. This is unnecessary, and +calls to {@code rmic} can simply be omitted. + + + +@since JDK1.1 + + diff --git a/out/production/classes1/sql/package.html b/out/production/classes1/sql/package.html new file mode 100644 index 0000000..d60cb53 --- /dev/null +++ b/out/production/classes1/sql/package.html @@ -0,0 +1,340 @@ + + + + + + + + + + + +Provides the API for accessing and processing data stored in a +data source (usually a relational database) using the +JavaTM programming language. +This API includes a framework whereby different +drivers can be installed dynamically to access different data sources. +Although the JDBCTM API is mainly geared +to passing SQL statements to a database, it provides for reading and +writing data from any data source with a tabular format. +The reader/writer facility, available through the +javax.sql.RowSet group of interfaces, can be customized to +use and update data from a spread sheet, flat file, or any other tabular +data source. +

+

What the JDBCTM 4.2 API Includes

+The JDBCTM 4.2 API includes both +the java.sql package, referred to as the JDBC core API, +and the javax.sql package, referred to as the JDBC Optional +Package API. This complete JDBC API +is included in the JavaTM +Standard Edition (Java SETM), version 7. +The javax.sql package extends the functionality of the JDBC API +from a client-side API to a server-side API, and it is an essential part +of the JavaTM Enterprise Edition +(Java EETM) technology. +

+

Versions

+The JDBC 4.2 API incorporates all of the previous JDBC API versions: +
    +
  • The JDBC 4.1 API
    • +
  • The JDBC 4.0 API
    • +
  • The JDBC 3.0 API
    • +
  • The JDBC 2.1 core API
    • +
  • The JDBC 2.0 Optional Package API
    + (Note that the JDBC 2.1 core API and the JDBC 2.0 Optional Package + API together are referred to as the JDBC 2.0 API.)
    • +
  • The JDBC 1.2 API
    • +
  • The JDBC 1.0 API
    • +
+

+Classes, interfaces, methods, fields, constructors, and exceptions +have the following "since" tags that indicate when they were introduced +into the Java platform. When these "since" tags are used in +JavadocTM comments for the JDBC API, +they indicate the following: +

    +
  • Since 1.8 -- new in the JDBC 4.2 API and part of the Java SE platform, + version 8
    • +
  • Since 1.7 -- new in the JDBC 4.1 API and part of the Java SE platform, + version 7
    • +
  • Since 1.6 -- new in the JDBC 4.0 API and part of the Java SE platform, + version 6
    • +
  • Since 1.4 -- new in the JDBC 3.0 API and part of the J2SE platform, + version 1.4
    • +
  • Since 1.2 -- new in the JDBC 2.0 API and part of the J2SE platform, + version 1.2
    • +
  • Since 1.1 or no "since" tag -- in the original JDBC 1.0 API and part of + the JDKTM, version 1.1
    • +
+

+NOTE: Many of the new features are optional; consequently, there is +some variation in drivers and the features they support. Always +check your driver's documentation to see whether it supports a feature before +you try to use it. +

+NOTE: The class SQLPermission was added in the +JavaTM 2 SDK, Standard Edition, +version 1.3 release. This class is used to prevent unauthorized +access to the logging stream associated with the DriverManager, +which may contain information such as table names, column data, and so on. +

+ +

What the java.sql Package Contains

+The java.sql package contains API for the following: +
    +
  • Making a connection with a database via the DriverManager facility +
      +
    • DriverManager class -- makes a connection with a driver +
    • SQLPermission class -- provides permission when code + running within a Security Manager, such as an applet, + attempts to set up a logging stream through the + DriverManager +
    • Driver interface -- provides the API for registering + and connecting drivers based on JDBC technology ("JDBC drivers"); + generally used only by the DriverManager class +
    • DriverPropertyInfo class -- provides properties for a + JDBC driver; not used by the general user +
    +
  • Sending SQL statements to a database +
      +
    • Statement -- used to send basic SQL statements +
    • PreparedStatement -- used to send prepared statements or + basic SQL statements (derived from Statement) +
    • CallableStatement -- used to call database stored + procedures (derived from PreparedStatement) +
    • Connection interface -- provides methods for creating + statements and managing connections and their properties +
    • Savepoint -- provides savepoints in a transaction + +
    +
  • Retrieving and updating the results of a query +
      +
    • ResultSet interface +
    +
  • Standard mappings for SQL types to classes and interfaces in the + Java programming language +
      +
    • Array interface -- mapping for SQL ARRAY +
    • Blob interface -- mapping for SQL BLOB +
    • Clob interface -- mapping for SQL CLOB +
    • Date class -- mapping for SQL DATE +
    • NClob interface -- mapping for SQL NCLOB +
    • Ref interface -- mapping for SQL REF +
    • RowId interface -- mapping for SQL ROWID +
    • Struct interface -- mapping for SQL STRUCT +
    • SQLXML interface -- mapping for SQL XML +
    • Time class -- mapping for SQL TIME +
    • Timestamp class -- mapping for SQL TIMESTAMP +
    • Types class -- provides constants for SQL types +
    +
  • Custom mapping an SQL user-defined type (UDT) to a class in the + Java programming language +
      +
    • SQLData interface -- specifies the mapping of + a UDT to an instance of this class +
    • SQLInput interface -- provides methods for reading + UDT attributes from a stream +
    • SQLOutput interface -- provides methods for writing + UDT attributes back to a stream +
    +
  • Metadata +
      +
    • DatabaseMetaData interface -- provides information + about the database +
    • ResultSetMetaData interface -- provides information + about the columns of a ResultSet object +
    • ParameterMetaData interface -- provides information + about the parameters to PreparedStatement commands +
    +
  • Exceptions +
      +
    • SQLException -- thrown by most methods when there + is a problem accessing data and by some methods for other reasons +
    • SQLWarning -- thrown to indicate a warning +
    • DataTruncation -- thrown to indicate that data may have + been truncated +
    • BatchUpdateException -- thrown to indicate that not all + commands in a batch update executed successfully +
    +
+

+

java.sql and javax.sql Features Introduced in the JDBC 4.2 API

+
    +
  • Added JDBCType enum and SQLType interface
    • +
  • Support for REF CURSORS in CallableStatement +
    • +
  • DatabaseMetaData methods to return maximum Logical LOB size + and if Ref Cursors are supported
    • +
  • Added support for large update counts
    • + +
+

+

java.sql and javax.sql Features Introduced in the JDBC 4.1 API

+
    +
  • Allow Connection, + ResultSet and Statement objects to be + used with the try-with-resources statement
    • +
  • Supported added to CallableStatement and + ResultSet to specify the Java type to convert to via the + getObject method
    • +
  • DatabaseMetaData methods to return PseudoColumns and if a + generated key is always returned
    • +
  • Added support to Connection to specify a database schema, + abort and timeout a physical connection.
    • +
  • Added support to close a Statement object when its dependent + objects have been closed
    • +
  • Support for obtaining the parent logger for a Driver, + DataSource, ConnectionPoolDataSource and + XADataSource
    • + +
+

java.sql and javax.sql Features Introduced in the JDBC 4.0 API

+
    +
  • auto java.sql.Driver discovery -- no longer need to load a +java.sql.Driver class via Class.forName +
  • National Character Set support added +
  • Support added for the SQL:2003 XML data type +
  • SQLException enhancements -- Added support for cause chaining; New SQLExceptions + added for common SQLState class value codes +
  • Enhanced Blob/Clob functionality -- Support provided to create and free a Blob/Clob instance + as well as additional methods added to improve accessibility +
  • Support added for accessing a SQL ROWID +
  • Support added to allow a JDBC application to access an instance of a JDBC resource + that has been wrapped by a vendor, usually in an application server or connection + pooling environment. +
  • Availability to be notified when a PreparedStatement that is associated + with a PooledConnection has been closed or the driver determines is invalid + + +
+

+

+

java.sql and javax.sql Features Introduced in the JDBC 3.0 API

+
    +
  • Pooled statements -- reuse of statements associated with a pooled + connection +
  • Savepoints -- allow a transaction to be rolled back to a designated + savepoint +
  • Properties defined for ConnectionPoolDataSource -- specify + how connections are to be pooled +
  • Metadata for parameters of a PreparedStatement object +
  • Ability to retrieve values from automatically generated columns +
  • Ability to have multiple ResultSet objects + returned from CallableStatement objects open at the + same time +
  • Ability to identify parameters to CallableStatement + objects by name as well as by index +
  • ResultSet holdability -- ability to specify whether cursors + should be held open or closed at the end of a transaction +
  • Ability to retrieve and update the SQL structured type instance that a + Ref object references +
  • Ability to programmatically update BLOB, + CLOB, ARRAY, and REF values. +
  • Addition of the java.sql.Types.DATALINK data type -- + allows JDBC drivers access to objects stored outside a data source +
  • Addition of metadata for retrieving SQL type hierarchies +
+

+

java.sql Features Introduced in the JDBC 2.1 Core API

+
    +
  • Scrollable result sets--using new methods in the ResultSet + interface that allow the cursor to be moved to a particular row or to a + position relative to its current position +
  • Batch updates +
  • Programmatic updates--using ResultSet updater methods +
  • New data types--interfaces mapping the SQL3 data types +
  • Custom mapping of user-defined types (UDTs) +
  • Miscellaneous features, including performance hints, the use of character + streams, full precision for java.math.BigDecimal values, + additional security, and + support for time zones in date, time, and timestamp values. +
+

+

javax.sql Features Introduced in the JDBC 2.0 Optional +Package API

+
    +
  • The DataSource interface as a means of making a connection. The + Java Naming and Directory InterfaceTM + (JNDI) is used for registering a DataSource object with a + naming service and also for retrieving it. +
  • Pooled connections -- allowing connections to be used and reused +
  • Distributed transactions -- allowing a transaction to span diverse + DBMS servers +
  • RowSet technology -- providing a convenient means of + handling and passing data +
+

+

+

Custom Mapping of UDTs

+A user-defined type (UDT) defined in SQL can be mapped to a class in the Java +programming language. An SQL structured type or an SQL DISTINCT +type are the UDTs that may be custom mapped. The following three +steps set up a custom mapping: +
    +
  1. Defining the SQL structured type or DISTINCT type in SQL +
  2. Defining the class in the Java programming language to which the + SQL UDT will be mapped. This class must implement the + SQLData interface. +
  3. Making an entry in a Connection object's type map + that contains two things: +
      +
    • the fully-qualified SQL name of the UDT +
    • the Class object for the class that implements the + SQLData interface +
    +
+

+When these are in place for a UDT, calling the methods +ResultSet.getObject or CallableStatement.getObject +on that UDT will automatically retrieve the custom mapping for it. Also, the +PreparedStatement.setObject method will automatically map the +object back to its SQL type to store it in the data source. + +

Package Specification

+ + + +

Related Documentation

+ + +

+@since 1.1 + + diff --git a/out/production/classes1/text/package.html b/out/production/classes1/text/package.html new file mode 100644 index 0000000..a8b0397 --- /dev/null +++ b/out/production/classes1/text/package.html @@ -0,0 +1,65 @@ + + + + + + + + +Provides classes and interfaces for handling text, dates, numbers, and messages +in a manner independent of natural languages. This means your main application +or applet can be written to be language-independent, and it can rely upon +separate, dynamically-linked localized resources. This allows the flexibility +of adding localizations for new localizations at any time. +

+These classes are capable of formatting dates, numbers, and messages, parsing; +searching and sorting strings; and iterating over characters, words, sentences, +and line breaks. This package contains three main groups of classes and +interfaces: +

    +
  • Classes for iteration over text +
  • Classes for formatting and parsing +
  • Classes for string collation +
+ + +@since JDK1.1 + + diff --git a/out/production/classes1/text/spi/package.html b/out/production/classes1/text/spi/package.html new file mode 100644 index 0000000..fa08ec1 --- /dev/null +++ b/out/production/classes1/text/spi/package.html @@ -0,0 +1,50 @@ + + + + + + + +Service provider classes for the classes in the java.text package. + + +@since 1.6 + + diff --git a/out/production/classes1/time/overview.html b/out/production/classes1/time/overview.html new file mode 100644 index 0000000..ef102f8 --- /dev/null +++ b/out/production/classes1/time/overview.html @@ -0,0 +1,169 @@ + + +

+ A new Date and Time API for Java. + The design includes a relatively large number of classes and methods, + however each follows a common design language, especially in method prefixes. + Once the prefixes are understood, the API is relatively simple to comprehend. +

+

+ The Java Time API is composed of several packages, each with a primary function: +

+

+ {@link java.time} contains the main API based on the ISO-8601 standard. + The classes defined here represent the principal date-time concepts, + including instants, durations, dates, times, time-zones and periods. + They are based on the ISO calendar system, which is the de facto world + calendar following the proleptic Gregorian rules. + All the classes are immutable and thread-safe. +

+

+ {@link java.time.temporal} contains the API for accessing the fields and units + of date-time. Units are measurable, such as years, months and hours. + For example, the expression "2 hours later" uses the hours unit. + By contrast, fields are mini-calculations, defining a value. + For example, month-of-year, day-of-week and hour-of-day are all fields. + The set of supported units and fields can be extended by applications if desired. +

+

+ {@link java.time.format} contains the API to print and parse fields into date-time + objects and to customize parsing and printing. + Formatters can be created in a variety of ways, including constants, patterns, + localized styles and a builder. + Formatters are immutable and thread-safe. +

+

+ {@link java.time.zone} contains the API to handle time-zones. + Detailed information is made available about the rules of each time-zone. +

+

+ {@link java.time.chrono} contains the basic part of the calendar neutral API + and alternate calendar systems. + This is intended for use by applications that need to use localized calendars. + Support is provided for the Hijrah, Japanese, Minguo, and Thai Buddhist Calendars. +

+

Design notes

+

+ Where possible, the API avoids the use of null. + All methods define whether they accept or return null in the Javadoc. + As a general rule, methods do not accept or return null. + A key exception is any method that takes an object and returns a boolean, for the purpose + of checking or validating, will generally return false for null. +

+

+ The API is designed to be type-safe where reasonable in the main high-level API. + Thus, there are separate classes for the distinct concepts of date, time and date-time, plus variants + for offset and time-zones. The core 7 date-time classes, plus Instant, handle the needs of most applications. + Further classes handle other combinations - year, year-month and month-day in a type-safe manner. +

+

+ In a language like Java, the use of many different types tends to cause API bloat. + This is handled here through the use of common method naming patterns throughout the API. + The common prefixes are 'of', 'get', 'is', 'with', 'plus', 'minus', 'to' and 'at'. + See {@link java.time.LocalDate} for an example of each of these methods. +

+

+ Following type-safety to its logical conclusion would result in more classes, especially for time - + hour-minute, hour-minute-second and hour-minute-second-nanosecond. + While logically pure, this was not possible in practice, as the additional classes would have + excessively complicated the API. Notably, there would be additional combinations at the offset + and date-time levels, such as offset-date-hour-minute. + To avoid this explosion of types, {@link java.time.LocalTime} is used for all precisions of time. + By contrast, some additional classes were used for dates, such as {@link java.time.YearMonth}. + This proved necessary, as the API for year-month is significantly different to that for a date, whereas + an absence of nanoseconds in a time can be approximated by returning zero. +

+

+ Similarly, full type-safety might argue for a separate class for each field in date-time, + such as a class for HourOfDay and another for DayOfMonth. + This approach was tried, but was excessively complicated in the Java language, lacking usability. + A similar problem occurs with periods. + There is a case for a separate class for each period unit, such as a type for Years and a type for Minutes. + However, this yields a lot of classes and a problem of type conversion. + As such, general access to fields and units is not wrapped in a class. +

+

+ Multiple calendar systems is an awkward addition to the design challenges. + The first principal is that most users want the standard ISO calendar system. + As such, the main classes are ISO-only. The second principal is that most of those that want a + non-ISO calendar system want it for user interaction, thus it is a UI localization issue. + As such, date and time objects should be held as ISO objects in the data model and persistent + storage, only being converted to and from a local calendar for display. + The calendar system would be stored separately in the user preferences. +

+

+ There are, however, some limited use cases where users believe they need to store and use + dates in arbitrary calendar systems throughout the application. + This is supported by {@link java.time.chrono.ChronoLocalDate}, however it is vital to read + all the associated warnings in the Javadoc of that interface before using it. + In summary, applications that require general interoperation between multiple calendar systems + typically need to be written in a very different way to those only using the ISO calendar, + thus most applications should just use ISO and avoid {@code ChronoLocalDate}. +

+

+ Throughout all of this, a key goal was to allow date-time fields and units to be defined by applications. + This has been achieved having tried many different designs. +

+ diff --git a/out/production/classes1/util/CurrencyData.properties b/out/production/classes1/util/CurrencyData.properties new file mode 100644 index 0000000..5f2656e --- /dev/null +++ b/out/production/classes1/util/CurrencyData.properties @@ -0,0 +1,598 @@ +# +# Copyright (c) 2000, 2014, Oracle and/or its affiliates. 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. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Version of the currency data format. +# 1: initial +# 2: Change in minor unit (allowing 4-9 digits) +formatVersion=2 + +# Version of the currency code information in this class. +# It is a serial number that accompanies with each amendment. + +dataVersion=159 + +# List of all valid ISO 4217 currency codes. +# To ensure compatibility, do not remove codes. + +all=ADP020-AED784-AFA004-AFN971-ALL008-AMD051-ANG532-AOA973-ARS032-ATS040-AUD036-\ + AWG533-AYM945-AZM031-AZN944-BAM977-BBD052-BDT050-BEF056-BGL100-BGN975-BHD048-BIF108-\ + BMD060-BND096-BOB068-BOV984-BRL986-BSD044-BTN064-BWP072-BYB112-BYR974-\ + BZD084-CAD124-CDF976-CHE947-CHF756-CHW948-CLF990-CLP152-CNY156-COP170-COU970-CRC188-CSD891-CUP192-CUC931-\ + CVE132-CYP196-CZK203-DEM276-DJF262-DKK208-DOP214-DZD012-EEK233-EGP818-\ + ERN232-ESP724-ETB230-EUR978-FIM246-FJD242-FKP238-FRF250-GBP826-GEL981-\ + GHC288-GHS936-GIP292-GMD270-GNF324-GRD300-GTQ320-GWP624-GYD328-HKD344-HNL340-\ + HRK191-HTG332-HUF348-IDR360-IEP372-ILS376-INR356-IQD368-IRR364-ISK352-\ + ITL380-JMD388-JOD400-JPY392-KES404-KGS417-KHR116-KMF174-KPW408-KRW410-\ + KWD414-KYD136-KZT398-LAK418-LBP422-LKR144-LRD430-LSL426-LTL440-LUF442-\ + LVL428-LYD434-MAD504-MDL498-MGA969-MGF450-MKD807-MMK104-MNT496-MOP446-MRO478-\ + MTL470-MUR480-MVR462-MWK454-MXN484-MXV979-MYR458-MZM508-MZN943-NAD516-NGN566-\ + NIO558-NLG528-NOK578-NPR524-NZD554-OMR512-PAB590-PEN604-PGK598-PHP608-\ + PKR586-PLN985-PTE620-PYG600-QAR634-ROL946-RON946-RSD941-RUB643-RUR810-RWF646-SAR682-\ + SBD090-SCR690-SDD736-SDG938-SEK752-SGD702-SHP654-SIT705-SKK703-SLL694-SOS706-\ + SRD968-SRG740-SSP728-STD678-SVC222-SYP760-SZL748-THB764-TJS972-TMM795-TMT934-TND788-TOP776-\ + TPE626-TRL792-TRY949-TTD780-TWD901-TZS834-UAH980-UGX800-USD840-USN997-USS998-UYI940-\ + UYU858-UZS860-VEB862-VEF937-VND704-VUV548-WST882-XAF950-XAG961-XAU959-XBA955-\ + XBB956-XBC957-XBD958-XCD951-XDR960-XFO000-XFU000-XOF952-XPD964-XPF953-\ + XPT962-XSU994-XTS963-XUA965-XXX999-YER886-YUM891-ZAR710-ZMK894-ZMW967-ZWD716-ZWL932-\ + ZWN942-ZWR935 + + +# Mappings from ISO 3166 country codes to ISO 4217 currency codes. +# +# Three forms are used: +# Form 1: = +# Form 2: =;