handle (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.util.LazyUndoable
- - com.goldencode.p2j.util.BaseDataType
  - - com.goldencode.p2j.util.handle

All Implemented Interfaces:

Undoable, java.io.Externalizable, java.io.Serializable, java.lang.Comparable

Direct Known Subclasses:

HandleFieldRef, HandlePropertyRef
```
public class handle
extends BaseDataType
```
A class that represents a Progress 4GL compatible handle data type. This is a container for an object of type WrappedResource. Such objects can be passed around as a regular BaseDataType wrapper but the backing object can be indirectly accessed via the get() method.
The following is the mapping of Progress language features to the corresponding feature in this class:
```
 string        function (default format)      toString()
                        (user-defined format) toString(String) 
                        (export format)       toStringExport()
 valid-handle  function                       isValid()
 widget-handle function                       fromString(com.goldencode.p2j.util.character)
 
```
There are 2 deviations between this class and its behavior in the Progress 4GL:
1. The default format string is larger in Java than in Progress since the Java implementation uses all possible 32-bit values as its handle identifiers. This could be made compatible by limiting the possible values used to those that would fit into the Progress equivalent. This would probably require that every handle be registered or assigned a unique value at construction.
2. In Progress, it is possible that one could create a loop to instantiate all possible handles using the WIDGET-HANDLE function. This means that one might not have used the STRING function to get the text representation since that loop could create strings for all integers in the possible range of handle identifiers. This seems like a bad practice, but if it is ever used in reality, it would invalidate the implementation of fromString(com.goldencode.p2j.util.character) which depends upon a map maintained during toString(). The solution is the same as for the oversized text representation problem above (a registry created at construction of every handle).
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`handle.DummyResource` A pseudo-resource with a set id.
`static class`	`handle.Helper` Helper to expose APIs which have direct access to the context-local state.
`static class`	`handle.InvalidAttributeAccess` Handler for the `invalidAttrAccessProxy` proxy.
`private static class`	`handle.WorkArea` Stores global data relating to the state of the current context.

Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType
BaseDataType.Type, BaseDataType.WrapperHandler

Field Summary

Fields
Modifier and Type	Field and Description
`private static HandleCommon`	`invalidAttrAccessProxy` Dynamic proxy returned by unwrap APIs when the handle is invalid or not of the expected type.
`private static CentralLogger`	`LOG` Logger
`private boolean`	`possibleChained` Flags a possible intermediary handle used in a chained construction (like a:b:c).
`static java.lang.Object`	`UNKNOWN_ARGUMENT` A marker for the unknown value of the argument of `readOnlyError()`.
`private WrappedResource`	`value` Stores the referenced data of this handle.
`private static ContextLocal<handle.WorkArea>`	`work` Stores context-local state variables.
`private static WrappedResource`	`ZERO_RESOURCE` A "zero" pseudo-resource.

Constructor Summary

Constructors
Constructor and Description
`handle()` Default constructor, creates an instance that represents the unknown value.
`handle(BaseDataType value)` This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e.
`handle(boolean possibleChained)` Default constructor, creates an instance that represents the unknown value.
`handle(CommonFrame value)` Constructs an instance that has the contained object reference.
`handle(handle value)` Constructs an instance that has the contained object reference and `unknown value` that exactly matches that of the passed-in instance.
`handle(Stream stream)` Constructs an instance that has the contained object reference.
`handle(java.lang.String initVal)` Constructor used to create values from `initial` value.
`handle(WrappedResource value)` Constructs an instance that has the contained object reference.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`_isValid()` Determines if this instance is valid (to be used).
`boolean`	`_isValidEvent(character event)` Verifies whether the specified event is valid for the widget referenced by this handle.
`boolean`	`_isValidEvent(java.lang.String event)` Verifies whether the specified event is valid for the widget referenced by this handle.
`void`	`assign(BaseDataType value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(handle value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(java.lang.Object value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(Stream value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(Undoable value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(WrappedResource value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`static handle`	`buildExternalResource()` Build an `ExternalResource` instance and associated an ID to it.
`int`	`compareTo(java.lang.Object obj)` Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance.
`java.lang.String`	`defaultFormatString()` Return the default display format string for this type.
`boolean`	`delayPersistentSet()` Indicate if in a {@code RUN ...
`handle`	`duplicate()` Does the same as standard `clone()` method but returns an instance of `BaseDataType` and doesn't throw the `CloneNotSupportedException`.
`static handle`	`fromResourceId(java.lang.Long resourceId)` Converts the number representation of a handle into the original handle instance.
`static handle`	`fromResourceId(java.lang.Long resourceId, boolean defaultZero)` Converts the number representation of a handle into the original handle instance.
`static handle`	`fromResourceId(java.lang.Long resourceId, boolean defaultZero, boolean legacyHandleFunct)` Converts the number representation of a handle into the original handle instance.
`static handle`	`fromString(character txt)` Convert the string representation of a handle into the original handle instance.
`static handle`	`fromString(java.lang.String txt)` Convert the string representation of a handle into the original handle instance.
`static handle`	`fromString(java.lang.String txt, boolean defaultZero)` Convert the string representation of a handle into the original handle instance.
`java.lang.Object`	`get()` Returns the value of this instance as an `Object`.
`private static java.lang.String`	`getAttrOrMethodName(java.lang.reflect.Method method, java.lang.Object[] args)` Get the legacy attribute or method name mapped by this method.
`static handle.Helper`	`getHelper()` Get an instance of `handle.Helper`, which has the context-local instance saved, so API access can be done without a context-local query.
`WrappedResource`	`getResource()` Getter for the wrapped resource.
`static WrappedResource`	`getResource(handle h)` Get the underlying resource for this handle.
`java.lang.Long`	`getResourceId()` Get resource ID as a long value.
`BaseDataType.Type`	`getType()` Get the type
`int`	`hashCode()` Hash code implementation which is consistent with `BaseDataType.equals(java.lang.Object)`.
`BaseDataType`	`instantiateDefault()` Creates a new instance of the same type that represents the default initialized value.
`BaseDataType`	`instantiateUnknown()` Creates a new instance of the same type that represents the `unknown value`.
`static void`	`invalidAttribute(java.lang.String attr, boolean setter, java.lang.String type)` This API should be called only in case of a attribute/method access using a resource which does not support it.
`static void`	`invalidAttribute(java.lang.String attr, handle h, boolean setterMode)` This API should be called only in case of a attribute/method access using a resource which does not support it.
`static void`	`invalidAttribute(java.lang.String attr, java.lang.String accessMode, java.lang.String subtype, java.lang.String type)` This API should be called only in case of a attribute/method access using a resource which does not support it.
`boolean`	`isExternalResource()` Check if this resource is an `ExternalResource`.
`static boolean`	`isHandleTypeOf(handle handleToCheck, java.lang.Class<?> clazz)` Check the type of resource in the handle.
`protected boolean`	`isIncompatibleTypesOnConversion(BaseDataType value)` Returns true if dynamic data type conversion should not be attempted, it can also throws in case of incompatible types for a POLY conversion.
`boolean`	`isType(java.lang.String someType)` Checks whether the resource object is of a specified type (case insensitive).
`boolean`	`isUnknown()` Determines if this instance represents the `unknown value`.
`logical`	`isValid()` Determines if this instance is valid (to be used).
`logical`	`isValidEvent(character event)` Verifies whether the specified event is valid for the widget referenced by this handle.
`logical`	`isValidEvent(java.lang.String event)` Verifies whether the specified event is valid for the widget referenced by this handle.
`(package private) static boolean`	`knownResource(WrappedResource resource)` Check if the given resource is known (has an associated ID).
`void`	`readExternal(java.io.ObjectInput in)` Replacement for the default object reading method.
`static void`	`readOnlyError(handle h, java.lang.String attribute)` Emitted and to be used only in cases the attribute is read-only.
`static void`	`readOnlyError(handle h, java.lang.String attribute, java.lang.Object expr)` Emitted and to be used only in cases the attribute is read-only.
`static void`	`removeResource(WrappedResource resource)` Remove the given resource from the context-local map of all resource.
`static java.lang.Long`	`resourceId(WrappedResource resource)` Get the ID of the given resource, as used by the `toString()` and `fromString(com.goldencode.p2j.util.character)` APIs.
`void`	`set(WrappedResource value)` Set the value of this instance as a `WrappedResource`.
`void`	`setUnknown()` Sets the state of this instance's `unknown value` flag to `true`.
`java.lang.String`	`toString()` Creates a string representation of the instance data using the format `ResourceIdHelper.DEFAULT_FORMAT`.
`java.lang.String`	`toString(java.lang.String fmt)` Creates a string representation of the instance data using the user specified format string (Progress 4GL compatible) or if no such string is provided, the default format of `ResourceIdHelper.DEFAULT_FORMAT`.
`java.lang.String`	`toStringExport()` Creates a string representation of the instance data using the 'export' format.
`java.lang.String`	`toStringMessage()` Creates a string representation of the instance data in a form that is compatible with the `MESSAGE` language statement.
`CommonHandleChain`	`unwrap()` Unwrap this handle to a `CommonHandleChain` instance.
`ADMData`	`unwrapADMData()` Unwrap this handle to a `ADMData` instance.
`AsyncRequest`	`unwrapAsync()` Unwrap this handle to a `AsyncRequest` instance.
`AsyncRequestCountAttribute`	`unwrapAsyncRequestCount()` Unwrap this handle to a `AsyncRequestCountAttribute` instance.
`CommonAuditControl`	`unwrapAuditControl()` Unwrap this handle to a `CommonAuditControl` instance.
`CommonAuditPolicy`	`unwrapAuditPolicy()` Unwrap this handle to a `CommonAuditPolicy` instance.
`AutoReturnElement`	`unwrapAutoReturnElement()` Unwrap this handle to a `AutoReturnElement` instance.
`AutoZapElement`	`unwrapAutoZapElement()` Unwrap this handle to a `AutoZapElement` instance.
`Available`	`unwrapAvailable()` Unwrap this handle to a `Available` instance.
`BlankInterface`	`unwrapBlank()` Unwrap this handle to a `BlankInterface` instance.
`BoxInterface`	`unwrapBox()` Unwrap this handle to a `BoxInterface` instance.
`BrowseInterface`	`unwrapBrowse()` Unwrap this handle to a `BrowseInterface` instance.
`BrowseColumnInterface`	`unwrapBrowseColumn()` Unwrap this handle to a `BrowseColumnInterface` instance.
`BrowseElement`	`unwrapBrowseElement()` Unwrap this handle to a `BrowseElement` instance.
`Buffer`	`unwrapBuffer()` Unwrap this handle to a `Buffer` instance.
`BufferCollection`	`unwrapBufferCollection()` Unwrap this handle to a `BufferCollection` instance.
`BufferField`	`unwrapBufferField()` Unwrap this handle to a `BufferField` instance.
`ButtonInterface`	`unwrapButton()` Unwrap this handle to a `ButtonInterface` instance.
`ButtonList`	`unwrapButtonList()` Unwrap this handle to the button-list widget interface (ButtonList).
`ButtonListGroup`	`unwrapButtonListGroup()` Unwrap this handle to the button-list widget interface (ButtonListGroup).
`ButtonListGroupItem`	`unwrapButtonListGroupItem()` Unwrap this handle to the button-list widget interface (ButtonListGroupItem).
`Calendar`	`unwrapCalendar()` Unwrap this handle to the calendar widget interface.
`CallResource`	`unwrapCall()` Unwrap this handle to a `CallResource` instance.
`CallbackProcedure`	`unwrapCallbackProcedure()` Unwrap this handle to a `CallbackProcedure` instance.
`Checkable`	`unwrapCheckable()` Unwrap this handle to a `Checkable` instance.
`Clearable`	`unwrapClearable()` Unwrap this handle to a `Clearable` instance.
`ClientPrincipalResource`	`unwrapClientPrincipal()` Unwrap this handle to a `ClientPrincipalResource` instance.
`Clipboard`	`unwrapClipboard()` Unwrap this handle to a `Clipboard` instance.
`ColorTableResource`	`unwrapColorTable()` Unwrap this handle to a `ColorTableResource` instance.
`ComData`	`unwrapComData()` Unwrap this handle to the com data interface.
`CommonField`	`unwrapCommonField()` Unwrap this handle to a `CommonField` instance.
`CommonListWidget<?>`	`unwrapCommonListWidget()` Unwrap this handle to a `CommonWidget` instance.
`CommonProcedure`	`unwrapCommonProcedure()` Unwrap this handle to a `CommonProcedure` instance.
`CommonSessionId`	`unwrapCommonSessionId()` Unwrap this handle to a `CommonSessionId` instance.
`Compiler`	`unwrapCompiler()` Unwrap this handle to a `Compiler` instance.
`Connectable`	`unwrapConnectable()` Unwrap this handle to a `Connectable` instance.
`ConnectableServer`	`unwrapConnectableServer()` Unwrap this handle to a `ConnectableServer` instance.
`ControlFrame`	`unwrapControlFrame()` Unwrap this handle to a `ControlFrame` instance.
`Coordinates`	`unwrapCoordinates()` Unwrap this handle to a `Coordinates` instance.
`CreateLike`	`unwrapCreateLike()` Unwrap this handle to a `CreateLike` instance.
`CustomFont`	`unwrapCustomFont()` Unwrap this handle to a `CustomFont` instance.
`DatabaseInfo`	`unwrapDatabaseInfo()` Unwrap this handle to a `DatabaseInfo` instance.
`DataObject`	`unwrapDataObject()` Unwrap this handle to a `DataObject` instance.
`DataRelationInterface`	`unwrapDataRelation()` Unwrap this handle to a `DataRelationInterface` instance.
`DataSetInterface`	`unwrapDataSet()` Unwrap this handle to a `DataSetInterface` instance.
`DataSetChangeable`	`unwrapDataSetChangeable()` Unwrap this handle to a `DataSetChangeable` instance.
`DataSourceInterface`	`unwrapDataSource()` Unwrap this handle to a `DataSourceInterface` instance.
`DataSourceModifiable`	`unwrapDataSourceModifiable()` Unwrap this handle to a `DataSourceModifiable` instance.
`DeblankInterface`	`unwrapDeblank()` Unwrap this handle to a `DeblankInterface` instance.
`DebuggerResource`	`unwrapDebugger()` Unwrap this handle to a `DebuggerResource` instance.
`Dereferenceable`	`unwrapDereferenceable()` Unwrap this handle to a `Dereferenceable` instance.
`DirectManipulation`	`unwrapDirectManipulation()` Unwrap this handle to a `DirectManipulation` instance.
`DisableRedraw`	`unwrapDisableRedraw()` Unwrap this handle to a `DisableRedraw` instance.
`Down`	`unwrapDown()` Unwrap this handle to a `Down` instance.
`Droppable`	`unwrapDroppable()` Unwrap this handle to a `Droppable` instance.
`LegacyDsLogManager`	`unwrapDsLogManager()` Unwrap this handle to a `LegacyDsLogManager` instance.
`DynamicResource`	`unwrapDynamicResource()` Unwrap this handle to a `DynamicResource` instance.
`EditorInterface`	`unwrapEditor()` Unwrap this handle to an `EditorInterface` instance.
`EmailSender`	`unwrapEmailSender()` Unwrap this handle to a `EmailSender` instance.
`EmptyTempTable`	`unwrapEmptyTempTable()` Unwrap this handle to a `EmptyTempTable` instance.
`Enabled`	`unwrapEnabled()` Unwrap this handle to a `Enabled` instance.
`Encoding`	`unwrapEncoding()` Unwrap this handle to a `XmlSchema` instance.
`Errorable`	`unwrapError()` Unwrap this handle to a `Errorable` instance.
`CommonErrorStatus`	`unwrapErrorStatus()` Unwrap this handle to a `CommonErrorStatus` instance.
`ErrorString`	`unwrapErrorString()` Unwrap this handle to a `ErrorString` instance.
`EventProcedure`	`unwrapEventProcedure()` Unwrap this handle to a `EventProcedure` instance.
`FieldGroupInterface`	`unwrapFieldGroup()` Unwrap this handle to an `FieldGroupInterface` instance.
`CommonFile`	`unwrapFile()` Unwrap this handle to a `CommonFile` instance.
`CommonFileInfo`	`unwrapFileInfo()` Unwrap this handle to a `CommonFileInfo` instance.
`Fillable`	`unwrapFillable()` Unwrap this handle to a `Fillable` instance.
`FirstLastProcedureAttribute`	`unwrapFirstLastProcedure()` Unwrap this handle to a `FirstLastProcedureAttribute` instance.
`FontTableResource`	`unwrapFontTable()` Unwrap this handle to a `FontTableResource` instance.
`FrameInterface`	`unwrapFrame()` Unwrap this handle to an `FrameInterface` instance.
`FwdReport`	`unwrapFwdReport()` Unwrap this handle to a `FwdReport` instance.
`FWDTimer`	`unwrapFWDTimer()` Unwrap this handle to a `FWDTimer` instance.
`HtmlBrowser`	`unwrapHtmlBrowser()` Unwrap this handle to a `HtmlBrowser` instance.
`ImageList`	`unwrapImageList()` Unwrap this handle to a `ImageList` instance.
`ImageOnly`	`unwrapImageOnly()` Unwrap this handle to a `ImageOnly` instance.
`ImageSupport`	`unwrapImageSupport()` Unwrap this handle to a `ImageSupport` instance.
`ImageWidgetSupport`	`unwrapImageWidgetSupport()` Unwrap this handle to a `ImageWidgetSupport` instance.
`private static <T> T`	`unwrapImpl(handle h, java.lang.Class<T> ifc)` Unwrap the given handle so that it returns an instance compatible with the given interface, `ifc`.
`IndexedInterface`	`unwrapIndexed()` Unwrap this handle to a `IndexedInterface` instance.
`IndexInformation`	`unwrapIndexInformation()` Unwrap this handle to a `IndexInformation` instance.
`InnerLines`	`unwrapInnerLines()` Unwrap this handle to a `InnerLines` instance.
`InstantiatingProcedure`	`unwrapInstantiatingProcedure()` Unwrap this handle to a `InstantiatingProcedure` instance.
`IterableResource`	`unwrapIterableResource()` Unwrap this handle to a `IterableResource` instance.
`IterCounter`	`unwrapIterCounter()` Unwrap this handle to a `IterCounter` instance.
`JsonData`	`unwrapJsonData()` Unwrap this handle to a `JsonData` instance.
`Keyable`	`unwrapKeyable()` Unwrap this handle to a `Keyable` instance.
`Labels`	`unwrapLabels()` Unwrap this handle to a `Labels` instance.
`CommonLastEvent`	`unwrapLastEvent()` Unwrap this handle to a `CommonLastEvent` instance.
`ListImages`	`unwrapListImages()` Unwrap this handle to ListImages.
`LocalName`	`unwrapLocalName()` Unwrap this handle to a `LocalName` instance.
`LegacyLogManager`	`unwrapLogManager()` Unwrap this handle to a `LegacyLogManager` instance.
`MaxCharsElement`	`unwrapMaxCharsElement()` Unwrap this handle to a `MaxCharsElement` instance.
`MenuInterface`	`unwrapMenu()` Unwrap this handle to an `MenuInterface` instance.
`MenuItemInterface`	`unwrapMenuItem()` Unwrap this handle to an `MenuItemInterface` instance.
`MinHeightCharsInterface`	`unwrapMinHeightChars()` Unwrap this handle to a `MinHeightCharsInterface` instance.
`MnemonicInterface`	`unwrapMnemonic()` Unwrap this handle to an `MnemonicInterface` instance.
`Multiple`	`unwrapMultiple()` Unwrap this handle to a `Multiple` instance.
`NamedSerializable`	`unwrapNamedSerializable()` Unwrap this handle to a `NamedSerializable` instance.
`NamespaceURI`	`unwrapNamespaceURI()` Unwrap this handle to a `NamespaceURI` instance.
`Nodes`	`unwrapNodes()` Unwrap this handle to a `Nodes` instance.
`NumEntries`	`unwrapNumEntries()` Unwrap this handle to a `NumEntries` instance.
`NumItems`	`unwrapNumItems()` Unwrap this handle to a `NumItems` instance.
`OcxDragDrop`	`unwrapOcxDragDrop()` Unwrap this handle to a `OcxDragDrop` instance.
`OcxMouse`	`unwrapOcxMouse()` Unwrap this handle to a `OcxMouse` instance.
`Openable`	`unwrapOpenable()` Unwrap this handle to a `Openable` instance.
`OrientationInterface`	`unwrapOrientation()` Unwrap this handle to a `OrientationInterface` instance.
`CommonPane`	`unwrapPane()` Unwrap this handle to a `CommonPane` instance.
`PaneEntity<?>`	`unwrapPaneEntity()` Unwrap this handle to a `PaneEntity` instance.
`PasswordFieldInterface`	`unwrapPasswordField()` Unwrap this handle to a `PasswordFieldInterface` instance.
`PersistableProcedure`	`unwrapPersistableProcedure()` Unwrap this handle to a `PersistableProcedure` instance.
`PrimaryIndex`	`unwrapPrimary()` Unwrap this handle to a `PrimaryIndex` instance.
`PersistentProcedure`	`unwrapProcedure()` Unwrap this handle to a `PersistentProcedure` instance.
`Profiler`	`unwrapProfiler()` Unwrap this handle to a `Profiler` instance.
`ProgressBar`	`unwrapProgressBar()` Unwrap this handle to a `ProgressBar` instance.
`P2JQuery`	`unwrapQuery()` Unwrap this handle to a `P2JQuery` instance.
`QueryAssociable`	`unwrapQueryAssociable()` Unwrap this handle to a `QueryAssociable` instance.
`RadioSetInterface`	`unwrapRadioSet()` Unwrap this handle to a `RadioSetInterface` instance.
`RcodeInfo`	`unwrapRcodeInfo()` Unwrap this handle to a `RcodeInfo` instance.
`RectangleInterface`	`unwrapRectangle()` Unwrap this handle to a `RectangleInterface` instance.
`RefCounter`	`unwrapRefCounter()` Unwrap this handle to a `RefCounter` instance.
`Rejectable`	`unwrapRejectable()` Unwrap this handle to a `Rejectable` instance.
`Remotable`	`unwrapRemotable()` Unwrap this handle to a `Remotable` instance.
`RemoveNode`	`unwrapRemoveNode()` Unwrap this handle to a `RemoveNode` instance.
`ReplaceInterface`	`unwrapReplace()` Unwrap this handle to an `ReplaceInterface` instance.
`RequestResponseInfo`	`unwrapRequestResponseInfo()` Unwrap this handle to a `RequestResponseInfo` instance.
`ResultListHandler`	`unwrapResultListHandler()` Unwrap this handle to a `ResultListHandler` instance.
`SaxAttributes`	`unwrapSaxAttributes()` Unwrap this handle to a `SaxAttributes` instance.
`SaxEntity`	`unwrapSaxEntity()` Unwrap this handle to a `SaxEntity` instance.
`SaxReader`	`unwrapSaxReader()` Unwrap this handle to a `SaxReader` instance.
`SaxWriter`	`unwrapSaxWriter()` Unwrap this handle to a `SaxWriter` instance.
`ScrollbarHorizontalElement`	`unwrapScrollbarHorizontalElement()` Unwrap this handle to a `ScrollbarHorizontalElement` instance.
`ScrollbarVerticalElement`	`unwrapScrollbarVerticalElement()` Unwrap this handle to a `ScrollbarVerticalElement` instance.
`CommonSecurityPolicy`	`unwrapSecurityPolicy()` Unwrap this handle to a `CommonSecurityPolicy` instance.
`SelectableText`	`unwrapSelectableText()` Unwrap this handle to a `SelectableText` instance.
`SelectionListInterface`	`unwrapSelectionList()` Unwrap this handle to a `SelectionListInterface` instance.
`Sensitive`	`unwrapSensitive()` Unwrap this handle to a `Sensitive` instance.
`SerializeHiddenable`	`unwrapSerializeHiddenable()` Unwrap this handle to a `SerializeHiddenable` instance.
`Server`	`unwrapServer()` Unwrap this handle to a `Server` instance.
`CommonSession`	`unwrapSession()` Unwrap this handle to a `CommonProcedure` instance.
`Signature`	`unwrapSignature()` Unwrap this handle to a `Signature` instance.
`Sizeable`	`unwrapSizeable()` Unwrap this handle to a `Sizeable` instance.
`SliderInterface`	`unwrapSlider()` Unwrap this handle to a `SliderInterface` instance.
`SOAPEntity`	`unwrapSOAPEntity()` Unwrap this handle to a `SOAPEntity` instance.
`SOAPFault`	`unwrapSOAPFault()` Unwrap this handle to a `SOAPFault` instance.
`SOAPHeader`	`unwrapSOAPHeader()` Unwrap this handle to a `SOAPHeader` instance.
`SOAPHeaderEntry`	`unwrapSOAPHeaderEntry()` Unwrap this handle to a `SOAPHeaderEntry` instance.
`Socket`	`unwrapSocket()` Unwrap this handle to a `Socket` instance.
`SocketListener`	`unwrapSocketListener()` Unwrap this handle to a `SocketListener` instance.
`SortedElement`	`unwrapSortedElement()` Unwrap this handle to a `SortedElement` instance.
`Spreadsheet`	`unwrapSpreadsheet()` Unwrap this handle to a `Spreadsheet` instance.
`SslServerAttribute`	`unwrapSslServerAttribute()` Unwrap this handle to a `SslServerAttribute` instance.
`Stream`	`unwrapStream()` Unwrap this handle to a `Stream` instance.
`SubTypeAttribute`	`unwrapSubType()` Unwrap this handle to a `SubTypeAttribute` instance.
`TabSet`	`unwrapTabSet()` Unwrap this handle to a `TabSet` instance.
`TempTable`	`unwrapTempTable()` Unwrap this handle to a `TempTable` instance.
`TempTableDuplicator`	`unwrapTempTableDuplicator()` Unwrap this handle to a `TempTableDuplicator` instance.
`TitledElement`	`unwrapTitledElement()` Unwrap this handle to a `TitledElement` instance.
`TopOnlyInterface`	`unwrapTopOnly()` Unwrap this handle to an `TopOnlyInterface` instance.
`TransactionResource`	`unwrapTransaction()` Unwrap this handle to a `TransactionResource` instance.
`CommonHandleTree`	`unwrapTree()` Unwrap this handle to a `CommonHandleTree` instance.
`TreeFace`	`unwrapTreeFace()` Unwrap this handle to a `TreeFace` instance.
`TreeList`	`unwrapTreeList()` Unwrap this handle to a `TreeList` instance.
`TreeNodeCollection`	`unwrapTreeNodeCollection()` Unwrap this handle to a `TreeNodeCollection` instance.
`TreeNodeFace`	`unwrapTreeNodeFace()` Unwrap this handle to a `TreeNodeFace` instance.
`TreeView`	`unwrapTreeView()` Unwrap this handle to a `TreeView` instance.
`CommonHandle`	`unwrapType()` Unwrap this handle to a `CommonHandle` instance.
`UniqueID`	`unwrapUniqueID()` Unwrap this handle to a `UniqueID` instance.
`HasVisible`	`unwrapVisible()` Unwrap this handle to a `HasVisible` instance.
`WebContextResource`	`unwrapWebContext()` Unwrap this handle to a `WebContextResource` instance.
`CommonWidget`	`unwrapWidget()` Unwrap this handle to a `CommonWidget` instance.
`WidgetExtension`	`unwrapWidgetExtension()` Gets the instance of WidgetExtension.
`CommonWindow`	`unwrapWindow()` Unwrap this handle to a `CommonWindow` instance.
`WithCaption`	`unwrapWithCaption()` Gets the instance of WithCaption.
`WriteProtectable`	`unwrapWriteProtectable()` Unwrap this handle to a `WriteProtectable` instance.
`XCommon`	`unwrapXCommon()` Unwrap this handle to a `XCommon` instance.
`XDocument`	`unwrapXDocument()` Unwrap this handle to a `XDocument` instance.
`XEntity`	`unwrapXEntity()` Unwrap this handle to a `XEntity` instance.
`XmlData`	`unwrapXmlData()` Unwrap this handle to a `XmlData` instance.
`XmlNode`	`unwrapXmlNode()` Unwrap this handle to a `XmlNode` instance.
`XmlSchema`	`unwrapXmlSchema()` Unwrap this handle to a `XmlSchema` instance.
`XNodeRef`	`unwrapXNodeRef()` Unwrap this handle to a `XNodeRef` instance.
`void`	`writeExternal(java.io.ObjectOutput out)` Replacement for the default object writing method.

Methods inherited from class com.goldencode.p2j.util.BaseDataType
assign, calcFormatLength, createProxy, createProxy, deepCopy, elementsOfType, equals, fallback, formatLength, fromTypeName, generateDefault, generateUnknown, getAssigner, getSize, getTypeName, incompatibleTypesOnConversion, initialize, initializeDefaultExtent, instantiateDefaultExtent, invalidInitializer, isAllKnown, isAllKnown, isAssignDirect, isProxy, isUnknownValue, maximum, minimum, notUnknownValue, sameType, val, variable

Methods inherited from class com.goldencode.p2j.util.LazyUndoable
changed, checkUndoable, checkUndoable, checkUndoable, getTransLevel, isGlobal, isUndoable, markUndoable, popBlock, rollback, setGlobal

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOG
```
private static final CentralLogger LOG
```
    Logger
  - work
```
private static final ContextLocal<handle.WorkArea> work
```
    Stores context-local state variables.
  - invalidAttrAccessProxy
```
private static HandleCommon invalidAttrAccessProxy
```
    Dynamic proxy returned by unwrap APIs when the handle is invalid or not of the expected type. Gets populated on class load.
  - value
```
private WrappedResource value
```
    Stores the referenced data of this handle.
  - possibleChained
```
private boolean possibleChained
```
    Flags a possible intermediary handle used in a chained construction (like a:b:c). In this case the error is different (10068 instead of 3135/3140).
  - UNKNOWN_ARGUMENT
```
public static final java.lang.Object UNKNOWN_ARGUMENT
```
    A marker for the unknown value of the argument of readOnlyError(). The semantic of it is that the value was not passed from ABL code, not that it is ABL ? value.
  - ZERO_RESOURCE
```
private static final WrappedResource ZERO_RESOURCE
```
    A "zero" pseudo-resource. A "zero" resource is used for handles created by the fromString(String) method when a formally valid ID is provided, but the ID doesn't denote a valid resource.
    A zero resource is not valid but is not unknown.
- Constructor Detail
  - handle
```
public handle()
```
    Default constructor, creates an instance that represents the unknown value.
  - handle
```
public handle(boolean possibleChained)
```
    Default constructor, creates an instance that represents the unknown value.
    
    Parameters:
    
    possibleChained - Flags a possible intermediary handle used in a chained construction
  - handle
```
public handle(BaseDataType value)
```
    This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e. DYNAMIC-FUNCTION()). In such cases, the 4GL does some automatic type conversion (see assign(BaseDataType)).
    
    Parameters:
    
    value - The value to be used for this instance.
  - handle
```
public handle(java.lang.String initVal)
```
    Constructor used to create values from initial value. For this datatype, there are no options, only the ? (unknown) value is actually expected.
    
    Parameters:
    
    initVal - Ignored. Always create an unknown handle.
  - handle
```
public handle(handle value)
```
    Constructs an instance that has the contained object reference and unknown value that exactly matches that of the passed-in instance.
    
    Parameters:
    
    value - The instance to pattern from.
  - handle
```
public handle(WrappedResource value)
```
    Constructs an instance that has the contained object reference.
    
    Parameters:
    
    value - The instance to pattern from.
  - handle
```
public handle(Stream stream)
```
    Constructs an instance that has the contained object reference.
    
    Parameters:
    
    stream - The instance to pattern from.
  - handle
```
public handle(CommonFrame value)
```
    Constructs an instance that has the contained object reference.
    
    Parameters:
    
    value - The frame instance.
- Method Detail
  - getType
```
public BaseDataType.Type getType()
```
    Get the type
    
    Specified by:
    
    getType in class BaseDataType
    
    Returns:
    
    type
  - getHelper
```
public static handle.Helper getHelper()
```
    Get an instance of handle.Helper, which has the context-local instance saved, so API access can be done without a context-local query.
    
    Returns:
    
    See above.
  - isHandleTypeOf
```
public static boolean isHandleTypeOf(handle handleToCheck,
                                     java.lang.Class<?> clazz)
```
    Check the type of resource in the handle. Return true if and only if handle is valid and contains resource of specific type.
    
    Parameters:
    
    handleToCheck - The handle instance to check.
    
    clazz - Specific class type which will be compare.
    
    Returns:
    
    true if handleToCheck contains resource an instance of clazz, false otherwise.
  - getResource
```
public static WrappedResource getResource(handle h)
```
    Get the underlying resource for this handle.
    
    Parameters:
    
    h - The handle resource.
    
    Returns:
    
    The WrappedResource instance. If the handle is not valid, throw a ERROR condition.
  - readOnlyError
```
public static void readOnlyError(handle h,
                                 java.lang.String attribute)
```
    Emitted and to be used only in cases the attribute is read-only. It displays appropriate error message.
    
    Parameters:
    
    h - The handle used to access the attribute.
    
    attribute - The read-only attribute.
  - readOnlyError
```
public static void readOnlyError(handle h,
                                 java.lang.String attribute,
                                 java.lang.Object expr)
```
    Emitted and to be used only in cases the attribute is read-only. It displays appropriate error message.
    
    Parameters:
    
    h - The handle used to access the attribute.
    
    attribute - The read-only attribute.
    
    expr - The value which is attempted to be assigned to the read-only attribute.
  - fromString
```
public static handle fromString(character txt)
```
    Convert the string representation of a handle into the original handle instance. This facility can only work for handles that have been converted at least once into a string via toString(). Such handles are stored in a map for conversion purposes.
    
    Parameters:
    
    txt - A valid text representation of a handle.
    
    Returns:
    
    a handle instance
  - fromString
```
public static handle fromString(java.lang.String txt)
```
    Convert the string representation of a handle into the original handle instance. This facility can only work for handles that have been converted at least once into a string via toString(). Such handles are stored in a map for conversion purposes.
    
    Parameters:
    
    txt - A valid text representation of a handle.
    
    Returns:
    
    a handle instance
  - fromString
```
public static handle fromString(java.lang.String txt,
                                boolean defaultZero)
```
    Convert the string representation of a handle into the original handle instance. This facility can only work for handles that have been converted at least once into a string via toString(). Such handles are stored in a map for conversion purposes.
    
    Parameters:
    
    txt - A valid text representation of a handle.
    
    defaultZero - A flag indicating if the handle returned is the zero handle in case there is no resource with the specified id.
    
    Returns:
    
    a handle instance
  - fromResourceId
```
public static handle fromResourceId(java.lang.Long resourceId)
```
    Converts the number representation of a handle into the original handle instance.
    For handles whose backing resources still exist and which have been cached by their IDs via resourceId(WrappedResource) (which is called at various points in the handle's life cycle), the method returns a valid handle instance. For handles whose backing resources no longer exist, or which have never had their backing resources cached, the method returns a zero handle, i.e. handle with "0" string representation.
    
    Parameters:
    
    resourceId - Resource identifier.
    
    Returns:
    
    a handle instance
  - fromResourceId
```
public static handle fromResourceId(java.lang.Long resourceId,
                                    boolean defaultZero)
```
    Converts the number representation of a handle into the original handle instance.
    For handles whose backing resources still exist and which have been cached by their IDs via resourceId(WrappedResource) (which is called at various points in the handle's life cycle), the method returns a valid handle instance. For handles whose backing resources no longer exist, or which have never had their backing resources cached, the method returns a zero handle, i.e. handle with "0" string representation, or a dummy handle - an invalid handle with a specified string representation.
    
    Parameters:
    
    resourceId - Resource identifier.
    
    defaultZero - A flag indicating if the handle returned is the zero handle in case there is no resource with the specified id.
    
    Returns:
    
    a handle instance
  - fromResourceId
```
public static handle fromResourceId(java.lang.Long resourceId,
                                    boolean defaultZero,
                                    boolean legacyHandleFunct)
```
    Converts the number representation of a handle into the original handle instance.
    For handles whose backing resources still exist and which have been cached by their IDs via resourceId(WrappedResource) (which is called at various points in the handle's life cycle), the method returns a valid handle instance. For handles whose backing resources no longer exist, or which have never had their backing resources cached, the method returns a zero handle, i.e. handle with "0" string representation, or a dummy handle - an invalid handle with a specified string representation.
    
    Parameters:
    
    resourceId - Resource identifier.
    
    defaultZero - A flag indicating if the handle returned is the zero handle in case there is no resource with the specified id.
    
    legacyHandleFunct - Flag indicating if this call originates from a HANDLE function call.
    
    Returns:
    
    a handle instance
  - invalidAttribute
```
public static void invalidAttribute(java.lang.String attr,
                                    handle h,
                                    boolean setterMode)
```
    This API should be called only in case of a attribute/method access using a resource which does not support it. It shows appropriate error messages, depending on handle state and attribute/method.
    This must not be called in cases of a not-supported attribute invoked as a lvalue (i.e. a setter for a not-supported attribute is invoked). In this case, call readOnlyError(com.goldencode.p2j.util.handle, java.lang.String).
    
    Parameters:
    
    attr - The attribute/method name which is not supported by the handle.
    
    h - The handle used to access the attribute/method.
    
    setterMode - The access mode. Use true for setter and false for getter/query.
  - invalidAttribute
```
public static void invalidAttribute(java.lang.String attr,
                                    boolean setter,
                                    java.lang.String type)
```
    This API should be called only in case of a attribute/method access using a resource which does not support it. It shows error messages #4052 with the configured message string.
    
    Parameters:
    
    attr - The attribute/method name which is not supported by the handle.
    
    setter - The access mode. Use true for setter and false for getter/query.
    
    type - The type of the widget used to access the invalid attribute/method.
  - invalidAttribute
```
public static void invalidAttribute(java.lang.String attr,
                                    java.lang.String accessMode,
                                    java.lang.String subtype,
                                    java.lang.String type)
```
    This API should be called only in case of a attribute/method access using a resource which does not support it. It shows error messages #4052 with the configured message string.
    
    Parameters:
    
    attr - The attribute/method name which is not supported by the handle.
    
    accessMode - The access mode. Use true for setter and false for getter/query.
    
    subtype - The subtype of the widget used to access the invalid attribute/method.
    
    type - The type of the widget used to access the invalid attribute/method.
  - removeResource
```
public static void removeResource(WrappedResource resource)
```
    Remove the given resource from the context-local map of all resource.
    This method should be called by all wrapped resources when deleted, that is all resources implementing WrappedResource interface.
    
    Parameters:
    
    resource - A resource instance to be removed.
  - resourceId
```
public static java.lang.Long resourceId(WrappedResource resource)
```
    Get the ID of the given resource, as used by the toString() and fromString(com.goldencode.p2j.util.character) APIs.
    The method allocates additional resources together with the provided wrapped resource, thus it is necessary that removeResource(WrappedResource) is called when the returned resource id is not needed anymore (i.e. the related resource is deleted), see removeResource(WrappedResource) for more details.
    
    Parameters:
    
    resource - A resource instance.
    
    Returns:
    
    The ID of this resource.
  - knownResource
```
static boolean knownResource(WrappedResource resource)
```
    Check if the given resource is known (has an associated ID).
    
    Parameters:
    
    resource - A resource, valid or not.
    
    Returns:
    
    true if the resource has an associated ID.
  - buildExternalResource
```
public static handle buildExternalResource()
```
    Build an ExternalResource instance and associated an ID to it.
    
    Returns:
    
    A handle with a new ExternalResource instance.
  - unwrapImpl
```
private static <T> T unwrapImpl(handle h,
                                java.lang.Class<T> ifc)
```
    Unwrap the given handle so that it returns an instance compatible with the given interface, ifc. If the handle is invalid or is not compatible with the given interface, a dynamic proxy is returned (see invalidAttrAccessProxy.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle. To return the wrapped resource for a call site that will not guarantee the attribute/method invocation use getResource() instead.
    
    Parameters:
    
    h - The handle to be unwrapped.
    
    ifc - The expected interface.
    
    Returns:
    
    See above.
  - getAttrOrMethodName
```
private static java.lang.String getAttrOrMethodName(java.lang.reflect.Method method,
                                                    java.lang.Object[] args)
```
    Get the legacy attribute or method name mapped by this method.
    
    Parameters:
    
    method - The method for which the legacy name is needed.
    
    args - The method's arguments.
    
    Returns:
    
    The legacy name from the method annotation or the converted API name, if not found in the respective annotation.
  - isExternalResource
```
public boolean isExternalResource()
```
    Check if this resource is an ExternalResource.
    
    Returns:
    
    true if this is an ExternalResource instance.
  - unwrap
```
public CommonHandleChain unwrap()
```
    Unwrap this handle to a CommonHandleChain instance. If the handle is not a procedure, widget, window or frame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTree
```
public CommonHandleTree unwrapTree()
```
    Unwrap this handle to a CommonHandleTree instance. If the handle is not a CommonHandleTree handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapADMData
```
public ADMData unwrapADMData()
```
    Unwrap this handle to a ADMData instance. If the handle is not a ADMData handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAsync
```
public AsyncRequest unwrapAsync()
```
    Unwrap this handle to a AsyncRequest instance. If the handle is not a AsynchronousRequest handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAsyncRequestCount
```
public AsyncRequestCountAttribute unwrapAsyncRequestCount()
```
    Unwrap this handle to a AsyncRequestCountAttribute instance. If the handle is not a AsyncRequestCountAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBuffer
```
public Buffer unwrapBuffer()
```
    Unwrap this handle to a Buffer instance. If the handle is not the Buffer handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBufferCollection
```
public BufferCollection unwrapBufferCollection()
```
    Unwrap this handle to a BufferCollection instance. If the handle is not the BufferCollection handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBufferField
```
public BufferField unwrapBufferField()
```
    Unwrap this handle to a BufferField instance. If the handle is not the BufferField handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCall
```
public CallResource unwrapCall()
```
    Unwrap this handle to a CallResource instance. If the handle is not the Call handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCheckable
```
public Checkable unwrapCheckable()
```
    Unwrap this handle to a Checkable instance. If the handle is not the Checkable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapClientPrincipal
```
public ClientPrincipalResource unwrapClientPrincipal()
```
    Unwrap this handle to a ClientPrincipalResource instance. If the handle is not the ClientPrincipal handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapClearable
```
public Clearable unwrapClearable()
```
    Unwrap this handle to a Clearable instance. If the handle is not the Clearable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapClipboard
```
public Clipboard unwrapClipboard()
```
    Unwrap this handle to a Clipboard instance. If the handle is not a Clipboard handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapColorTable
```
public ColorTableResource unwrapColorTable()
```
    Unwrap this handle to a ColorTableResource instance. If the handle is not a ColorTableResource handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCompiler
```
public Compiler unwrapCompiler()
```
    Unwrap this handle to a Compiler instance. If the handle is not a RcodeInfo handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapReplace
```
public ReplaceInterface unwrapReplace()
```
    Unwrap this handle to an ReplaceInterface instance. If the handle is not an EditorInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEditor
```
public EditorInterface unwrapEditor()
```
    Unwrap this handle to an EditorInterface instance. If the handle is not an EditorInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBrowse
```
public BrowseInterface unwrapBrowse()
```
    Unwrap this handle to a BrowseInterface instance. If the handle is not the BrowseInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapLabels
```
public Labels unwrapLabels()
```
    Unwrap this handle to a Labels instance. If the handle is not the Labels handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFieldGroup
```
public FieldGroupInterface unwrapFieldGroup()
```
    Unwrap this handle to an FieldGroupInterface instance.
    
    Returns:
    
    The field group interface instance.
  - unwrapFrame
```
public FrameInterface unwrapFrame()
```
    Unwrap this handle to an FrameInterface instance. If the handle is not an FrameInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTopOnly
```
public TopOnlyInterface unwrapTopOnly()
```
    Unwrap this handle to an TopOnlyInterface instance. If the handle is not an FrameInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAutoReturnElement
```
public AutoReturnElement unwrapAutoReturnElement()
```
    Unwrap this handle to a AutoReturnElement instance. If the handle is not the AutoReturnElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAutoZapElement
```
public AutoZapElement unwrapAutoZapElement()
```
    Unwrap this handle to a AutoZapElement instance. If the handle is not the AutoZapElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAvailable
```
public Available unwrapAvailable()
```
    Unwrap this handle to a Available instance. If the handle is not the Available handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapScrollbarHorizontalElement
```
public ScrollbarHorizontalElement unwrapScrollbarHorizontalElement()
```
    Unwrap this handle to a ScrollbarHorizontalElement instance. If the handle is not the ScrollbarHorizontalElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapScrollbarVerticalElement
```
public ScrollbarVerticalElement unwrapScrollbarVerticalElement()
```
    Unwrap this handle to a ScrollbarVerticalElement instance. If the handle is not the ScrollbarVerticalElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBrowseColumn
```
public BrowseColumnInterface unwrapBrowseColumn()
```
    Unwrap this handle to a BrowseColumnInterface instance. If the handle is not the BrowseColumnInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBrowseElement
```
public BrowseElement unwrapBrowseElement()
```
    Unwrap this handle to a BrowseElement instance. If the handle is not the BrowseElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTitledElement
```
public TitledElement unwrapTitledElement()
```
    Unwrap this handle to a TitledElement instance. If the handle is not the TitledElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapInnerLines
```
public InnerLines unwrapInnerLines()
```
    Unwrap this handle to a InnerLines instance. If the handle is not the InnerLines handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMaxCharsElement
```
public MaxCharsElement unwrapMaxCharsElement()
```
    Unwrap this handle to a MaxCharsElement instance. If the handle is not the MaxCharsElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSortedElement
```
public SortedElement unwrapSortedElement()
```
    Unwrap this handle to a SortedElement instance. If the handle is not the SortedElement handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCommonProcedure
```
public CommonProcedure unwrapCommonProcedure()
```
    Unwrap this handle to a CommonProcedure instance. If the handle is not a procedure or the SESSION system handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCommonField
```
public CommonField unwrapCommonField()
```
    Unwrap this handle to a CommonField instance. If the handle is not CommonField resource or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapConnectable
```
public Connectable unwrapConnectable()
```
    Unwrap this handle to a Connectable instance. If the handle is not a Connectable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapConnectableServer
```
public ConnectableServer unwrapConnectableServer()
```
    Unwrap this handle to a ConnectableServer instance. If the handle is not a ConnectableServer handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDatabaseInfo
```
public DatabaseInfo unwrapDatabaseInfo()
```
    Unwrap this handle to a DatabaseInfo instance. If the handle is not a procedure, widget, window or frame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDebugger
```
public DebuggerResource unwrapDebugger()
```
    Unwrap this handle to a DebuggerResource instance. If the handle is not a DEBUGGER handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDereferenceable
```
public Dereferenceable unwrapDereferenceable()
```
    Unwrap this handle to a Dereferenceable instance. If the handle is not the Dereferenceable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation to dereference(). This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDisableRedraw
```
public DisableRedraw unwrapDisableRedraw()
```
    Unwrap this handle to a DisableRedraw instance. If the handle is not the DisableRedraw handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation to dereference(). This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDynamicResource
```
public DynamicResource unwrapDynamicResource()
```
    Unwrap this handle to a DynamicResource instance. If the handle is not the DynamicResource handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation to dereference(). This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEncoding
```
public Encoding unwrapEncoding()
```
    Unwrap this handle to a XmlSchema instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapError
```
public Errorable unwrapError()
```
    Unwrap this handle to a Errorable instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapErrorString
```
public ErrorString unwrapErrorString()
```
    Unwrap this handle to a ErrorString instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapErrorStatus
```
public CommonErrorStatus unwrapErrorStatus()
```
    Unwrap this handle to a CommonErrorStatus instance. If the handle is not the ERROR-STATUS handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFile
```
public CommonFile unwrapFile()
```
    Unwrap this handle to a CommonFile instance. If the handle is not the FILE-INFO or a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFileInfo
```
public CommonFileInfo unwrapFileInfo()
```
    Unwrap this handle to a CommonFileInfo instance. If the handle is not the FILE-INFO handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFirstLastProcedure
```
public FirstLastProcedureAttribute unwrapFirstLastProcedure()
```
    Unwrap this handle to a FirstLastProcedureAttribute instance. If the handle is not a FirstLastProcedureAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFontTable
```
public FontTableResource unwrapFontTable()
```
    Unwrap this handle to a FontTableResource instance. If the handle is not a FontTableResource handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapInstantiatingProcedure
```
public InstantiatingProcedure unwrapInstantiatingProcedure()
```
    Unwrap this handle to a InstantiatingProcedure instance. If the handle is not a FirstLastProcedureAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapKeyable
```
public Keyable unwrapKeyable()
```
    Unwrap this handle to a Keyable instance. If the handle is not a FirstLastProcedureAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMenu
```
public MenuInterface unwrapMenu()
```
    Unwrap this handle to an MenuInterface instance. If the handle is not an MenuInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMnemonic
```
public MnemonicInterface unwrapMnemonic()
```
    Unwrap this handle to an MnemonicInterface instance. If the handle is not an MnemonicInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMenuItem
```
public MenuItemInterface unwrapMenuItem()
```
    Unwrap this handle to an MenuItemInterface instance. If the handle is not an MenuItemInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapNumEntries
```
public NumEntries unwrapNumEntries()
```
    Unwrap this handle to a NumEntries instance. If the handle is not a NumEntries handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapNumItems
```
public NumItems unwrapNumItems()
```
    Unwrap this handle to a NumItems instance. If the handle is not a NumItems handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapButton
```
public ButtonInterface unwrapButton()
```
    Unwrap this handle to a ButtonInterface instance. If the handle is not a ButtonInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapImageSupport
```
public ImageSupport unwrapImageSupport()
```
    Unwrap this handle to a ImageSupport instance. If the handle is not an ImageSupport handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapImageWidgetSupport
```
public ImageWidgetSupport unwrapImageWidgetSupport()
```
    Unwrap this handle to a ImageWidgetSupport instance. If the handle is not an ImageWidgetSupport handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapImageOnly
```
public ImageOnly unwrapImageOnly()
```
    Unwrap this handle to a ImageOnly instance. If the handle is not an ImageOnly handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapIterableResource
```
public IterableResource unwrapIterableResource()
```
    Unwrap this handle to a IterableResource instance.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapIndexed
```
public IndexedInterface unwrapIndexed()
```
    Unwrap this handle to a IndexedInterface instance.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSelectionList
```
public SelectionListInterface unwrapSelectionList()
```
    Unwrap this handle to a SelectionListInterface instance. If the handle is not a ButtonInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapOpenable
```
public Openable unwrapOpenable()
```
    Unwrap this handle to a Openable instance. If the handle is not a Openable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapOrientation
```
public OrientationInterface unwrapOrientation()
```
    Unwrap this handle to a OrientationInterface instance. If the handle is not a OrientationInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapComData
```
public ComData unwrapComData()
```
    Unwrap this handle to the com data interface.
    
    Returns:
    
    The com data interface
  - unwrapSlider
```
public SliderInterface unwrapSlider()
```
    Unwrap this handle to a SliderInterface instance. If the handle is not a ButtonInterface handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapLastEvent
```
public CommonLastEvent unwrapLastEvent()
```
    Unwrap this handle to a CommonLastEvent instance. If the handle is not the KEY-READER handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapListImages
```
public ListImages unwrapListImages()
```
    Unwrap this handle to ListImages.
    
    Returns:
    
    The ListImages instance.
  - unwrapLogManager
```
public LegacyLogManager unwrapLogManager()
```
    Unwrap this handle to a LegacyLogManager instance. If the handle is not the LOG-MANAGER handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDsLogManager
```
public LegacyDsLogManager unwrapDsLogManager()
```
    Unwrap this handle to a LegacyDsLogManager instance. If the handle is not the DSLOG-MANAGER handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapLocalName
```
public LocalName unwrapLocalName()
```
    Unwrap this handle to a LocalName instance. If the handle is not a LocalName handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapNamedSerializable
```
public NamedSerializable unwrapNamedSerializable()
```
    Unwrap this handle to a NamedSerializable instance. If the handle is not a NamedSerializable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapNamespaceURI
```
public NamespaceURI unwrapNamespaceURI()
```
    Unwrap this handle to a NamespaceURI instance. If the handle is not a NamedSerializable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapPane
```
public CommonPane unwrapPane()
```
    Unwrap this handle to a CommonPane instance. If the handle is not a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapPaneEntity
```
public PaneEntity<?> unwrapPaneEntity()
```
    Unwrap this handle to a PaneEntity instance. If the handle is not PaneEntity or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapPasswordField
```
public PasswordFieldInterface unwrapPasswordField()
```
    Unwrap this handle to a PasswordFieldInterface instance. If the handle is not a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapPersistableProcedure
```
public PersistableProcedure unwrapPersistableProcedure()
```
    Unwrap this handle to a PersistableProcedure instance. If the handle is not a persistable procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapProcedure
```
public PersistentProcedure unwrapProcedure()
```
    Unwrap this handle to a PersistentProcedure instance. If the handle is not a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCallbackProcedure
```
public CallbackProcedure unwrapCallbackProcedure()
```
    Unwrap this handle to a CallbackProcedure instance. If the handle is not a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFillable
```
public Fillable unwrapFillable()
```
    Unwrap this handle to a Fillable instance. If the handle is not a procedure handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapProfiler
```
public Profiler unwrapProfiler()
```
    Unwrap this handle to a Profiler instance. If the handle is not a Profiler handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapQuery
```
public P2JQuery unwrapQuery()
```
    Unwrap this handle to a P2JQuery instance. If the handle is not a query handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapQueryAssociable
```
public QueryAssociable unwrapQueryAssociable()
```
    Unwrap this handle to a QueryAssociable instance. If the handle is not a query handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapIndexInformation
```
public IndexInformation unwrapIndexInformation()
```
    Unwrap this handle to a IndexInformation instance. If the handle is not a query handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRcodeInfo
```
public RcodeInfo unwrapRcodeInfo()
```
    Unwrap this handle to a RcodeInfo instance. If the handle is not a RcodeInfo handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRemotable
```
public Remotable unwrapRemotable()
```
    Unwrap this handle to a Remotable instance. If the handle is not a Remotable handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRemoveNode
```
public RemoveNode unwrapRemoveNode()
```
    Unwrap this handle to a RemoveNode instance. If the handle is not a RemoveNode handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapResultListHandler
```
public ResultListHandler unwrapResultListHandler()
```
    Unwrap this handle to a ResultListHandler instance. If the handle is not a ResultListHandler handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRequestResponseInfo
```
public RequestResponseInfo unwrapRequestResponseInfo()
```
    Unwrap this handle to a RequestResponseInfo instance. If the handle is not a RequestResponseInfo handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSaxAttributes
```
public SaxAttributes unwrapSaxAttributes()
```
    Unwrap this handle to a SaxAttributes instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSaxEntity
```
public SaxEntity unwrapSaxEntity()
```
    Unwrap this handle to a SaxEntity instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSaxReader
```
public SaxReader unwrapSaxReader()
```
    Unwrap this handle to a SaxReader instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSaxWriter
```
public SaxWriter unwrapSaxWriter()
```
    Unwrap this handle to a SaxWriter instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSensitive
```
public Sensitive unwrapSensitive()
```
    Unwrap this handle to a Sensitive instance. If the handle is not a Sensitive handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapControlFrame
```
public ControlFrame unwrapControlFrame()
```
    Unwrap this handle to a ControlFrame instance. If the handle is not a ControlFrame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEmailSender
```
public EmailSender unwrapEmailSender()
```
    Unwrap this handle to a EmailSender instance. If the handle is not a EmailSender handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEnabled
```
public Enabled unwrapEnabled()
```
    Unwrap this handle to a Enabled instance. If the handle is not a Enabled handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEventProcedure
```
public EventProcedure unwrapEventProcedure()
```
    Unwrap this handle to a EventProcedure instance. If the handle is not a event procedure (for an async request) handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFWDTimer
```
public FWDTimer unwrapFWDTimer()
```
    Unwrap this handle to a FWDTimer instance. If the handle is not a FWDTimer handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDown
```
public Down unwrapDown()
```
    Unwrap this handle to a Down instance. If the handle is not a Down handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapServer
```
public Server unwrapServer()
```
    Unwrap this handle to a Server instance. If the handle is not a Server handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSerializeHiddenable
```
public SerializeHiddenable unwrapSerializeHiddenable()
```
    Unwrap this handle to a SerializeHiddenable instance. If the handle does not refer a SerializeHiddenable object or is invalid an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSession
```
public CommonSession unwrapSession()
```
    Unwrap this handle to a CommonProcedure instance. If the handle is not the SESSION system handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCommonSessionId
```
public CommonSessionId unwrapCommonSessionId()
```
    Unwrap this handle to a CommonSessionId instance. If the handle is not the SESSION system handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSizeable
```
public Sizeable unwrapSizeable()
```
    Unwrap this handle to a Sizeable instance. If the handle is not a procedure, widget, window or frame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSignature
```
public Signature unwrapSignature()
```
    Unwrap this handle to a Signature instance. If the handle is not a procedure, widget, window or frame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMultiple
```
public Multiple unwrapMultiple()
```
    Unwrap this handle to a Multiple instance. If the handle is not a procedure, widget, window or frame handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSOAPEntity
```
public SOAPEntity unwrapSOAPEntity()
```
    Unwrap this handle to a SOAPEntity instance. If the handle's resource is not implementing the SOAPEntity interface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSOAPFault
```
public SOAPFault unwrapSOAPFault()
```
    Unwrap this handle to a SOAPFault instance. If the handle's resource is not implementing the SOAPFault interface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSOAPHeader
```
public SOAPHeader unwrapSOAPHeader()
```
    Unwrap this handle to a SOAPHeader instance. If the handle's resource is not implementing the SOAPHeader interface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSOAPHeaderEntry
```
public SOAPHeaderEntry unwrapSOAPHeaderEntry()
```
    Unwrap this handle to a SOAPHeaderEntry instance. If the handle's resource is not implementing the SOAPHeaderEntry interface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSocket
```
public Socket unwrapSocket()
```
    Unwrap this handle to a Socket instance. If the handle is not the SOCKET handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSocketListener
```
public SocketListener unwrapSocketListener()
```
    Unwrap this handle to a SocketListener instance. If the handle is not the SERVER-SOCKET handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSpreadsheet
```
public Spreadsheet unwrapSpreadsheet()
```
    Unwrap this handle to a Spreadsheet instance. If the handle is not a FWDTimer handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSslServerAttribute
```
public SslServerAttribute unwrapSslServerAttribute()
```
    Unwrap this handle to a SslServerAttribute instance. If the handle is not a SslServerAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSubType
```
public SubTypeAttribute unwrapSubType()
```
    Unwrap this handle to a SubTypeAttribute instance. If the handle is not a SubTypeAttribute handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapStream
```
public Stream unwrapStream()
```
    Unwrap this handle to a Stream instance. If the handle is not a Stream handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTempTable
```
public TempTable unwrapTempTable()
```
    Unwrap this handle to a TempTable instance. If the handle is not a temporary handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapEmptyTempTable
```
public EmptyTempTable unwrapEmptyTempTable()
```
    Unwrap this handle to a EmptyTempTable instance. If the handle is not a temporary handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTempTableDuplicator
```
public TempTableDuplicator unwrapTempTableDuplicator()
```
    Unwrap this handle to a TempTableDuplicator instance. If the handle is not a temporary handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCreateLike
```
public CreateLike unwrapCreateLike()
```
    Unwrap this handle to a CreateLike instance. If the handle is not a temporary handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTransaction
```
public TransactionResource unwrapTransaction()
```
    Unwrap this handle to a TransactionResource instance. If the handle is not a Transaction handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapType
```
public CommonHandle unwrapType()
```
    Unwrap this handle to a CommonHandle instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapUniqueID
```
public UniqueID unwrapUniqueID()
```
    Unwrap this handle to a UniqueID instance. If the handle is not a UniqueID handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXCommon
```
public XCommon unwrapXCommon()
```
    Unwrap this handle to a XCommon instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXEntity
```
public XEntity unwrapXEntity()
```
    Unwrap this handle to a XEntity instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXDocument
```
public XDocument unwrapXDocument()
```
    Unwrap this handle to a XDocument instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXmlSchema
```
public XmlSchema unwrapXmlSchema()
```
    Unwrap this handle to a XmlSchema instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXNodeRef
```
public XNodeRef unwrapXNodeRef()
```
    Unwrap this handle to a XNodeRef instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapWebContext
```
public WebContextResource unwrapWebContext()
```
    Unwrap this handle to a WebContextResource instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapWidget
```
public CommonWidget unwrapWidget()
```
    Unwrap this handle to a CommonWidget instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSelectableText
```
public SelectableText unwrapSelectableText()
```
    Unwrap this handle to a SelectableText instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBox
```
public BoxInterface unwrapBox()
```
    Unwrap this handle to a BoxInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapMinHeightChars
```
public MinHeightCharsInterface unwrapMinHeightChars()
```
    Unwrap this handle to a MinHeightCharsInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapBlank
```
public BlankInterface unwrapBlank()
```
    Unwrap this handle to a BlankInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCalendar
```
public Calendar unwrapCalendar()
```
    Unwrap this handle to the calendar widget interface.
    
    Returns:
    
    The calendar widget interface
  - unwrapButtonList
```
public ButtonList unwrapButtonList()
```
    Unwrap this handle to the button-list widget interface (ButtonList).
    
    Returns:
    
    The button-list widget interface
  - unwrapButtonListGroup
```
public ButtonListGroup unwrapButtonListGroup()
```
    Unwrap this handle to the button-list widget interface (ButtonListGroup).
    
    Returns:
    
    The button-list widget interface
  - unwrapButtonListGroupItem
```
public ButtonListGroupItem unwrapButtonListGroupItem()
```
    Unwrap this handle to the button-list widget interface (ButtonListGroupItem).
    
    Returns:
    
    The button-list widget interface
  - unwrapDeblank
```
public DeblankInterface unwrapDeblank()
```
    Unwrap this handle to a DeblankInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDirectManipulation
```
public DirectManipulation unwrapDirectManipulation()
```
    Unwrap this handle to a DirectManipulation instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDroppable
```
public Droppable unwrapDroppable()
```
    Unwrap this handle to a Droppable instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCommonListWidget
```
public CommonListWidget<?> unwrapCommonListWidget()
```
    Unwrap this handle to a CommonWidget instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRadioSet
```
public RadioSetInterface unwrapRadioSet()
```
    Unwrap this handle to a RadioSetInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRectangle
```
public RectangleInterface unwrapRectangle()
```
    Unwrap this handle to a RectangleInterface instance. If the handle is not a widget handle or is invalid, an dynamic proxy is returned.
    
    Returns:
    
    The instance of RectangleInterface.
  - unwrapVisible
```
public HasVisible unwrapVisible()
```
    Unwrap this handle to a HasVisible instance. If the handle is not a handle with VISIBLE attribute or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapWindow
```
public CommonWindow unwrapWindow()
```
    Unwrap this handle to a CommonWindow instance. If the handle is a window handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCoordinates
```
public Coordinates unwrapCoordinates()
```
    Unwrap this handle to a Coordinates instance. If the handle is a window handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXmlNode
```
public XmlNode unwrapXmlNode()
```
    Unwrap this handle to a XmlNode instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapXmlData
```
public XmlData unwrapXmlData()
```
    Unwrap this handle to a XmlData instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapFwdReport
```
public FwdReport unwrapFwdReport()
```
    Unwrap this handle to a FwdReport instance. If the handle is not a Report handle or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapWriteProtectable
```
public WriteProtectable unwrapWriteProtectable()
```
    Unwrap this handle to a WriteProtectable instance. If the handle is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTreeFace
```
public TreeFace unwrapTreeFace()
```
    Unwrap this handle to a TreeFace instance. If the handle is not TreeFace or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTreeList
```
public TreeList unwrapTreeList()
```
    Unwrap this handle to a TreeList instance. If the handle is not TreeList or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTreeNodeCollection
```
public TreeNodeCollection unwrapTreeNodeCollection()
```
    Unwrap this handle to a TreeNodeCollection instance. If the handle is not TreeNodeCollection or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTreeView
```
public TreeView unwrapTreeView()
```
    Unwrap this handle to a TreeView instance. If the handle is not TreeView or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTreeNodeFace
```
public TreeNodeFace unwrapTreeNodeFace()
```
    Unwrap this handle to a TreeNodeFace instance. If the handle is not TreeNodeFace or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapNodes
```
public Nodes unwrapNodes()
```
    Unwrap this handle to a Nodes instance. If the handle is not Nodes or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapTabSet
```
public TabSet unwrapTabSet()
```
    Unwrap this handle to a TabSet instance. If the handle is not TabSet or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapHtmlBrowser
```
public HtmlBrowser unwrapHtmlBrowser()
```
    Unwrap this handle to a HtmlBrowser instance. If the handle is not HtmlBrowser or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapProgressBar
```
public ProgressBar unwrapProgressBar()
```
    Unwrap this handle to a ProgressBar instance. If the handle is not ProgressBar or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapPrimary
```
public PrimaryIndex unwrapPrimary()
```
    Unwrap this handle to a PrimaryIndex instance. If the handle is not PrimaryIndex or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapOcxMouse
```
public OcxMouse unwrapOcxMouse()
```
    Unwrap this handle to a OcxMouse instance. If the handle is not OcxMouse or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapOcxDragDrop
```
public OcxDragDrop unwrapOcxDragDrop()
```
    Unwrap this handle to a OcxDragDrop instance. If the handle is not OcxDragDrop or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRejectable
```
public Rejectable unwrapRejectable()
```
    Unwrap this handle to a Rejectable instance. If the handle is not Rejectable or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataObject
```
public DataObject unwrapDataObject()
```
    Unwrap this handle to a DataObject instance. If the handle is not DataObject or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataSet
```
public DataSetInterface unwrapDataSet()
```
    Unwrap this handle to a DataSetInterface instance. If the handle is not DataSetInterface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapIterCounter
```
public IterCounter unwrapIterCounter()
```
    Unwrap this handle to a IterCounter instance. If the handle is not IterCounter or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapRefCounter
```
public RefCounter unwrapRefCounter()
```
    Unwrap this handle to a RefCounter instance. If the handle is not RefCounter or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataSetChangeable
```
public DataSetChangeable unwrapDataSetChangeable()
```
    Unwrap this handle to a DataSetChangeable instance. If the handle is not DataSetChangeable or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataSourceModifiable
```
public DataSourceModifiable unwrapDataSourceModifiable()
```
    Unwrap this handle to a DataSourceModifiable instance. If the handle is not DataSourceModifiable or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataRelation
```
public DataRelationInterface unwrapDataRelation()
```
    Unwrap this handle to a DataRelationInterface instance. If the handle is not DataRelationInterface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapDataSource
```
public DataSourceInterface unwrapDataSource()
```
    Unwrap this handle to a DataSourceInterface instance. If the handle is not DataSourceInterface or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapJsonData
```
public JsonData unwrapJsonData()
```
    Unwrap this handle to a JsonData instance. If the handle is not JsonData or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapSecurityPolicy
```
public CommonSecurityPolicy unwrapSecurityPolicy()
```
    Unwrap this handle to a CommonSecurityPolicy instance. If the handle is not CommonSecurityPolicy or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAuditPolicy
```
public CommonAuditPolicy unwrapAuditPolicy()
```
    Unwrap this handle to a CommonAuditPolicy instance. If the handle is not CommonAuditPolicy or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapAuditControl
```
public CommonAuditControl unwrapAuditControl()
```
    Unwrap this handle to a CommonAuditControl instance. If the handle is not CommonAuditControl or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapCustomFont
```
public CustomFont unwrapCustomFont()
```
    Unwrap this handle to a CustomFont instance. If the handle is not CustomFont or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapImageList
```
public ImageList unwrapImageList()
```
    Unwrap this handle to a ImageList instance. If the handle is not ImageList or is invalid, an dynamic proxy is returned.
    Each unwrap call must be followed by an actual attribute/method invocation. This is needed because for invalid handles, a stack of handles is maintained, to know the state of the last used handle.
    
    Returns:
    
    See above.
  - unwrapWidgetExtension
```
public WidgetExtension unwrapWidgetExtension()
```
    Gets the instance of WidgetExtension.
    
    Returns:
    
    The instance of WidgetExtension
  - unwrapWithCaption
```
public WithCaption unwrapWithCaption()
```
    Gets the instance of WithCaption.
    
    Returns:
    
    The instance of WithCaption
  - instantiateUnknown
```
public BaseDataType instantiateUnknown()
```
    Creates a new instance of the same type that represents the unknown value.
    
    Specified by:
    
    instantiateUnknown in class BaseDataType
    
    Returns:
    
    An instance that represents the unknown value.
  - instantiateDefault
```
public BaseDataType instantiateDefault()
```
    Creates a new instance of the same type that represents the default initialized value.
    
    Specified by:
    
    instantiateDefault in class BaseDataType
    
    Returns:
    
    An instance that represents the default value.
  - duplicate
```
public handle duplicate()
```
    Does the same as standard clone() method but returns an instance of BaseDataType and doesn't throw the CloneNotSupportedException.
    
    Specified by:
    
    duplicate in class BaseDataType
    
    Returns:
    
    A clone of this instance.
  - hashCode
```
public int hashCode()
```
    Hash code implementation which is consistent with BaseDataType.equals(java.lang.Object).
    
    Specified by:
    
    hashCode in class BaseDataType
    
    Returns:
    
    Hash code value for this object instance.
  - get
```
public java.lang.Object get()
```
    Returns the value of this instance as an Object.
    If this instance represents the unknown value, a null will be returned.
    
    Returns:
    
    The value as an Object or null if this is unknown.
  - set
```
public void set(WrappedResource value)
```
    Set the value of this instance as a WrappedResource.
    
    Parameters:
    
    value - The value to be represented in this instance.
  - isValid
```
public logical isValid()
```
    Determines if this instance is valid (to be used).
    
    Returns:
    
    true if this instance can be used.
  - isValidEvent
```
public logical isValidEvent(character event)
```
    Verifies whether the specified event is valid for the widget referenced by this handle. For each type of widget, only certain events are valid. Corresponds VALID-EVENT function.
    
    Parameters:
    
    event - Name of the event.
    
    Returns:
    
    true if this handle references a widget and the specified event is valid for this type of widgets.
  - isValidEvent
```
public logical isValidEvent(java.lang.String event)
```
    Verifies whether the specified event is valid for the widget referenced by this handle. For each type of widget, only certain events are valid. Corresponds VALID-EVENT function.
    
    Parameters:
    
    event - Name of the event.
    
    Returns:
    
    true if this handle references a widget and the specified event is valid for this type of widgets.
  - _isValid
```
public boolean _isValid()
```
    Determines if this instance is valid (to be used).
    
    Returns:
    
    boolean true if this instance can be used.
  - _isValidEvent
```
public boolean _isValidEvent(java.lang.String event)
```
    Verifies whether the specified event is valid for the widget referenced by this handle. For each type of widget, only certain events are valid. Corresponds VALID-EVENT function.
    
    Parameters:
    
    event - Name of the event.
    
    Returns:
    
    true if this handle references a widget and the specified event is valid for this type of widgets.
  - _isValidEvent
```
public boolean _isValidEvent(character event)
```
    Verifies whether the specified event is valid for the widget referenced by this handle. For each type of widget, only certain events are valid. Corresponds VALID-EVENT function.
    
    Parameters:
    
    event - Name of the event.
    
    Returns:
    
    true if this handle references a widget and the specified event is valid for this type of widgets.
  - isUnknown
```
public boolean isUnknown()
```
    Determines if this instance represents the unknown value.
    
    Specified by:
    
    isUnknown in class BaseDataType
    
    Returns:
    
    true if this instance is set to the unknown value.
  - setUnknown
```
public void setUnknown()
```
    Sets the state of this instance's unknown value flag to true.
    Warning: a separate call is needed to ensure that the data of this instance is set to the correct value.
    
    Specified by:
    
    setUnknown in class BaseDataType
  - isIncompatibleTypesOnConversion
```
protected boolean isIncompatibleTypesOnConversion(BaseDataType value)
```
    Description copied from class: BaseDataType
    
    Returns true if dynamic data type conversion should not be attempted, it can also throws in case of incompatible types for a POLY conversion. (e.g. DYNAMIC-FUNCTION()).
    
    Overrides:
    
    isIncompatibleTypesOnConversion in class BaseDataType
  - assign
```
public void assign(BaseDataType value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    If the value is not of type handle, the following automatic type conversion will occur:
```
 unknown - The instance will be set to unknown value.
 handle  - The wrapped value will be assigned as expected.
 
```
    All other cases will generate an error.
    This variant is meant to handle the cases of built-in functions and methods in the 4GL which have polymorphic return types (e.g. DYNAMIC-FUNCTION()). This should NOT be used for non-polymorphic assignments.
    Specified by:
    
    assign in class BaseDataType
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(handle value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(WrappedResource value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(Stream value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(java.lang.Object value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Overrides:
    
    assign in class BaseDataType
    
    Parameters:
    
    value - The instance from which to copy state. This must be of type handle or WrappedResource.
  - assign
```
public void assign(Undoable value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - compareTo
```
public int compareTo(java.lang.Object obj)
```
    Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance. This is the implementation of the Comparable interface.
    The algorithm will fail to give meaningful results in the case where one tries to sort against other objects that do not represent compatible values.
    
    Parameters:
    
    obj - The instance to compare against.
    
    Returns:
    
    0 or 1 depending on if the passed instance is or is not unknown.
  - isType
```
public boolean isType(java.lang.String someType)
```
    Checks whether the resource object is of a specified type (case insensitive). If the handle is not valid or the resource is does not have a TYPE attribute, the method returns false.
    
    Parameters:
    
    someType - The type to check. Use the constants defined in LegacyResource to check the type of the resource.
    
    Returns:
    
    true if the type of this object matches the specified one.
  - delayPersistentSet
```
public boolean delayPersistentSet()
```
    Indicate if in a RUN ... PERSISTENT SET statement, this handle should receive the resource before the called procedure is executed (this returns false) or after the called procedure is executed (this returns true). Naturally, program handle variables are set before the called procedure is executed, so this should return false.
    
    Returns:
    
    true if the handle should be set after the called procedure is executed.
  - toString
```
public java.lang.String toString()
```
    Creates a string representation of the instance data using the format ResourceIdHelper.DEFAULT_FORMAT. If the instance represents the unknown value, a '?' will be returned.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    The formatted string.
  - toString
```
public java.lang.String toString(java.lang.String fmt)
```
    Creates a string representation of the instance data using the user specified format string (Progress 4GL compatible) or if no such string is provided, the default format of ResourceIdHelper.DEFAULT_FORMAT. If the instance represents the unknown value, a '?' will be returned.
    
    Specified by:
    
    toString in class BaseDataType
    
    Parameters:
    
    fmt - The Progress 4GL format string or null if the default format is to be used.
    
    Returns:
    
    The formatted string.
  - toStringMessage
```
public java.lang.String toStringMessage()
```
    Creates a string representation of the instance data in a form that is compatible with the MESSAGE language statement. If the instance represents the unknown value, a '?' will be returned.
    
    Specified by:
    
    toStringMessage in class BaseDataType
    
    Returns:
    
    The 'message' formatted string.
  - toStringExport
```
public java.lang.String toStringExport()
```
    Creates a string representation of the instance data using the 'export' format. If the instance represents the unknown value, a '?' will be returned.
    
    Specified by:
    
    toStringExport in class BaseDataType
    
    Returns:
    
    The 'export' formatted string.
  - defaultFormatString
```
public java.lang.String defaultFormatString()
```
    Return the default display format string for this type.
    Warning: this is larger than the Progress version because the range of handle values can be a 64-bit integer in this implementation.
    
    Specified by:
    
    defaultFormatString in class BaseDataType
    
    Returns:
    
    The default format string.
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
    Replacement for the default object reading method. The latest state is read from the input source.
    
    Parameters:
    
    in - The input source from which fields will be restored.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
    
    java.lang.ClassNotFoundException - If payload can't be instantiated.
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Replacement for the default object writing method. The latest state is written to the output destination.
    
    Parameters:
    
    out - The output destination to which fields will be saved.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
  - getResource
```
public WrappedResource getResource()
```
    Getter for the wrapped resource.
    
    Returns:
    
    The resource.
  - getResourceId
```
public java.lang.Long getResourceId()
```
    Get resource ID as a long value.
    
    Returns:
    
    Resource ID if any or null.

Class handle

Nested Class Summary

Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.goldencode.p2j.util.BaseDataType

Methods inherited from class com.goldencode.p2j.util.LazyUndoable

Methods inherited from class java.lang.Object

Field Detail

LOG

work

invalidAttrAccessProxy

value

possibleChained

UNKNOWN_ARGUMENT

ZERO_RESOURCE

Constructor Detail

handle

handle

handle

handle

handle

handle

handle

handle

Method Detail

getType

getHelper

isHandleTypeOf

getResource

readOnlyError

readOnlyError

fromString

fromString

fromString

fromResourceId

fromResourceId

fromResourceId

invalidAttribute

invalidAttribute

invalidAttribute

removeResource

resourceId

knownResource

buildExternalResource

unwrapImpl

getAttrOrMethodName

isExternalResource

unwrap

unwrapTree

unwrapADMData

unwrapAsync

unwrapAsyncRequestCount

unwrapBuffer

unwrapBufferCollection

unwrapBufferField

unwrapCall

unwrapCheckable

unwrapClientPrincipal

unwrapClearable

unwrapClipboard

unwrapColorTable

unwrapCompiler

unwrapReplace

unwrapEditor

unwrapBrowse

unwrapLabels

unwrapFieldGroup

unwrapFrame

unwrapTopOnly

unwrapAutoReturnElement

unwrapAutoZapElement

unwrapAvailable

unwrapScrollbarHorizontalElement

unwrapScrollbarVerticalElement

unwrapBrowseColumn

unwrapBrowseElement

unwrapTitledElement

unwrapInnerLines