| AbstractExtentParameter<T extends BaseDataType> |
Abstract class for special wrappers used for variables passed as extent parameters
to functions or procedures.
|
| AbstractParameter |
Base class for all types of parameters.
|
| AbstractParameter.Scope |
One instance of this class is created for each block scope which the currently executing
program enters.
|
| AbstractParameter.WorkArea |
Object which manages the context local state of field assigners.
|
| AbstractSimpleParameter |
Delegate worker for the variables or data-type wrapper implementations, which assigns an OUTPUT
or INPUT-OUTPUT parameter's value back to the variable / database field with which it is
associated, upon exit from a procedure or function.
|
| AccessorArrayWrapper |
Defines methods that provide access (get/set) to an array of
BaseDataType. |
| AccessorWrapper |
Defines methods an object that can provide access (get/set) to a
BaseDataType. |
| Accumulator |
Abstract base class for all accumulators.
|
| Accumulator.ExternalDataSource |
A data source implementation which expects to be fed its data from an
external source.
|
| AccumulatorManager |
Provides context-local scoped accumulators.
|
| AccumulatorManager.ContextContainer |
Simple ContextLocal subclass that properly initializes the
context-local reference to a new instance of a case-sensitive
ScopedSymbolDictionary that has a global scope.
|
| AccumulatorManager.WorkArea |
Stores global data relating to the state of the current context.
|
| Agent |
An apserver agent definition.
|
| Agent.AgentCommand |
Defines a command to be sent to an agent.
|
| Agent.AgentRemoteProcedure |
Defines some data which is required by the agent to know about any persistent procedure ran on it.
|
| AgentMonitor |
|
| AgentPool |
The main class for agent pooling.
|
| AgentPool.BoundPool |
Class implementing the behavior for STATE-RESET and STATE-AWARE operating modes.
|
| AgentPool.UnboundPool |
Class implementing the behavior for STATE-FREE and STATELESS operating modes.
|
| AppServerDefinition |
A container of all the settings of an appservers.
|
| AppServerHelper |
Provides a collection of APIs for connecting to the appserver and performing remote calls.
|
| AppServerLauncher |
This is a launcher of appservers and is used in two ways:
Automatically starts the appservers which have the auto_start=true in their
configuration; this will start up to initial_agents.
Allow starting of appservers remotely; if a server is started using the "-a appserver"
argument, it will connect to the target P2J Server and call AppServer.launch(java.lang.String) to
launch the specified appserver. |
| AppServerLauncher.Launcher |
Container for a Agent launching information.
|
| AppServerManager |
Manage the appservers defined by this P2J server by:
starting the agents when the appserver is started
listening and handling all incoming requests for the managed appservers
Also, it manages the appservers known to this P2J server.
|
| AppServerManager.RemoteAppServer |
Container for the information needed to identify an appserver, by the data configured at the
CONNECT statement's options.
|
| AppServerManager.WorkArea |
Container for agent-related info.
|
| ArrayAssigner |
Provides a simple helper to automate the assignment of each element of a
BaseDataType array based on 2 array inputs. |
| ArrayAssigner.WorkArea |
Stores global data relating to the state of the current context.
|
| AsyncRequestImpl |
Implements the async request resource.
|
| AuditControlManager |
Provides static methods implementing support for the
AUDIT-CONTROL system handle attributes and methods
See CommonAuditControl |
| AuditPolicyManager |
Provides static methods implementing support for the
AUDIT-POLICY system handle attributes and methods
See CommonAuditPolicy |
| AverageAccumulator |
An accumulator implementation which maintains a running, numeric total
and iteration count across all iterations of a loop, as well as across the
current break group.
|
| BaseDataType |
An abstract class that implements a Progress 4GL compatible data type
which has common logical operator processing.
|
| BaseDataType.WrapperHandler |
An invocation handler dedicated for BDT proxy.
|
| BaseDataTypeFactory |
Class responsible with instantiating a data type.
|
| BaseDataTypeVariable |
|
| BinaryData |
A class that implements common services for Progress 4GL compatible raw and memptr data types
whose data is mutable.
|
| BinaryData.RangeCheck |
Encapsulates a range check and allows the execution of it to be delegated to other code.
|
| blob |
Data wrapper type for SQL BLOB data.
|
| Block |
Base class for all code blocks.
|
| BlockDefinition |
Container of block information for Progress compatible rollback (undo)
commit and retry.
|
| BlockManager |
Provides an external API that allows the Progress-compatible code block
semantics to be provided with a minimum of code in the caller.
|
| BlockManager.BlockManagerHelper |
Helper to expose state in a way that avoids context local lookups.
|
| BlockManager.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| BlockManager.StatsHelper |
Server-wide hook that gets called at initialization and termination.
|
| BlockManager.WorkArea |
Stores global data relating to the state of the current context's
blocks.
|
| BlockRunner |
Helper to execute a 4GL code block with managed errors.
|
| BufferSizeManager |
BufferSizeManager indended to solve the following problem: after a process
stream fails, Progress can output some amount of data to the broken stream
without raising any error.
|
| CachedInputStream |
This class implements a cached instance of an input stream.
|
| Call |
Defines a CALL resources.
|
| Call.ExtentCallParameter |
A wrapper for extent parameters (without a subscript).
|
| Call.NativeCallParameter |
A wrapper for parameters which will be passed to a direct native OS API call.
|
| CallMode |
A container for the parameter's configured mode.
|
| CallParameter |
A wrapper for call parameters.
|
| character |
A class that represents a Progress 4GL compatible character object whose
data is mutable.
|
| character.CaseInsensitiveComparator |
|
| character.TestCase |
Encapsulates the logic of storing and executing a set of tests using
a minimum set of input (2 string operands and a set of boolean results
that are to be expected).
|
| CharacterExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a character result. |
| CharacterFormatParser |
Base class for Progress character format parsers/formatters.
|
| CharacterFormatter |
Implements the Progress STRING(value, format) function
for characters.
|
| CharsetConverter |
Provides optimized character set conversion routines.
|
| ChUIPrinterStreamSupport |
Creates remote stream instances for OUTPUT TO PRINTER statements.
|
| ClassEvent |
Management of class events.
|
| ClientPrincipal |
Implements the CLIENT-PRINCIPAL resource and all associated APIs.
|
| ClipboardManager |
Manages clipboard operations from the server.
|
| ClipboardManager.WorkArea |
Stores global data relating to the state of the current context.
|
| ClipboardStream |
Implements the output stream into the client's system clipboard.
|
| clob |
Data wrapper type for SQL CLOB data.
|
| comhandle |
A class that represents a Progress 4GL compatible COM handle data type.
|
| comhandle.WorkArea |
Stores global data relating to the state of the current context.
|
| ComhandleFieldRef |
Data wrapper which associates with a DMO property and provides direct access to this property.
|
| ComhandlePropertyRef |
Data wrapper which associates with a OO property and provides direct access to this property.
|
| CompareOps |
A class that provides Progress 4GL compatible comparison functions and
logical operators.
|
| CompilerOps |
Utility for working with COMPILER system handle and COMPILE statement.
|
| CompilerOps.WorkArea |
Stores global data relating to the state of the current context.
|
| ConfigItem<T> |
Core class for resolving clientConfig and webClient configs.
|
| Content |
Abstract class implementing the INI text file content.
|
| ControlFlowOps |
Progress compatible control-flow related static utility methods.
|
| ControlFlowOps.ArrayArgumentResolver |
This implementation resolves arguments for converted 4GL statements (RUN, function calls,
DYNAMIC-FUNCTION).
|
| ControlFlowOps.AsyncCall |
Helper class which also saves the AsyncRequestImpl instance, needed by the remote
request. |
| ControlFlowOps.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| ControlFlowOps.ControlFlowOpsHelper |
Helper to expose APIs which have direct access to the context-local state.
|
| ControlFlowOps.ExternalProcedureCaller |
Implements external program invocation.
|
| ControlFlowOps.ExternalProgramResolver |
Search through the available external programs for a match.
|
| ControlFlowOps.InternalEntryCaller |
Invoke the configured internal entry.
|
| ControlFlowOps.InternalEntryCaller.CacheKey |
A cache key which encapsulates the name of a method, its signature and containing class,
and whether that method represents a converted Progress function or a procedure.
|
| ControlFlowOps.InternalEntryCaller.CacheValue |
A data structure for the cache's values.
|
| ControlFlowOps.InternalProcSuperResolver |
Search through the super-procedures of the given procedure handle for
a match.
|
| ControlFlowOps.InternalResolver |
Search through the handle's defined internal-entries for a match.
|
| ControlFlowOps.InternalResolver.InternalEntryCacheKey |
Holds data of cached procedure internal entries
|
| ControlFlowOps.LastInvokeDetails |
The cached details of an invocation callsite.
|
| ControlFlowOps.MapArgumentResolver |
This is a special implementation of resolving arguments received in a Map, where
the key is the legacy argument's name (case insensitive) and the value is a string-encoded
representation of this argument.
|
| ControlFlowOps.MapToNotFound |
This caller is returned when the FUNCTION ...
|
| ControlFlowOps.NativeProcedureCaller |
Implements native procedure invocation (an API call to a shared library).
|
| ControlFlowOps.Resolver |
Abstract class.
|
| ControlFlowOps.SessionSuperResolver |
Search through the session's super-procedures of the handle for a match.
|
| ControlFlowOps.SuperResolver |
Search through the given super-procedure list for a match.
|
| ControlFlowOps.WorkArea |
Stores global data relating to the state of the current context.
|
| CountAccumulator |
A simple accumulator implementation which counts the total number of loop
iterations performed, as well as the number of loop iterations performed
within the current break group.
|
| CryptoUtils |
Provides helper classes for the 4GL cryptography
|
| CryptoUtils.CipherParams |
Symmetric cipher parameters
|
| DataSetSDOHelper |
Defines APIs to load DATASETs as Tuscany SDO.
|
| date |
A class that represents a Progress 4GL compatible date object whose
data is mutable.
|
| date.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| date.GMTCalendar |
Provides a thread local cache for a GMT calendar.
|
| date.NullCalendar |
Provides a thread local cache for a default calendar.
|
| date.TestCase |
Simple testcase wrapper to check Julian day number calculations.
|
| date.WorkArea |
Stores global data relating to the state of the current context.
|
| date.ZoneCalendar |
Provides a thread local cache for a timezone-specific calendar.
|
| DateExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a date result. |
| DateFormatParser |
Base class for Progress date format parsers/formatters.
|
| DateFormatter |
Progress date formatter.
|
| DateOps |
A class that provides Progress 4GL compatible date functions.
|
| datetime |
A class that represents a Progress 4GL compatible datetime object whose
data is mutable.
|
| DatetimeExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a datetime result. |
| DatetimeFormatParser |
Base class for Progress datetime/datetime-tz format parsers/formatters.
|
| datetimetz |
A class that represents a Progress 4GL compatible datetime-tz object whose
data is mutable.
|
| DatetimeTzExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a datetimetz result. |
| Debugger |
DEBUGGER legacy resource implementation.
|
| Debugger.WorkArea |
Stores global data relating to the state of the current context.
|
| decimal |
A class that represents a Progress 4GL compatible decimal object whose
data is mutable.
|
| decimal.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| decimal.WorkArea |
Stores global data relating to the state of the current context.
|
| DecimalExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a decimal result. |
| DeferredDeletablesManager |
Provides a mean of postponing deletion of deletable resources at a specific block level.
|
| DeferredProgram |
A deferred program is a configuration saved when a RUN ...
|
| DeferredProgramWrapper |
This program represents the instance used to assign to a handle, when a statement like
RUN ...
|
| DirStream |
A Stream class implementation for the INPUT FROM OS-DIR
Progress statement.
|
| DynamicArray<E> |
Maintains an array which can grow or shrink as needed to contain the
elements.
|
| DynamicOps |
A class that provides Progress 4GL compatible operators and functions that have dynamic
type behavior.
|
| EnumObject<T extends LegacyEnum> |
Wrapper class for all OO 4GL ENUM instance, defined as constants JVM-wide.
|
| EnvironmentOps |
Progress compatible environment-related static utility methods.
|
| EnvironmentOps.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| EnvironmentOps.WorkArea |
Stores global data relating to the state of the current context.
|
| ErrorManager |
A context-local class providing static methods to support the
ERROR-STATUS and NO-ERROR Progress features.
|
| ErrorManager.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| ErrorManager.ErrorEntry |
Stores the data related to a single error.
|
| ErrorManager.ErrorHelper |
Helper to expose error state in a way that avoids context local lookups.
|
| ErrorManager.ErrorStatus |
This class corresponds ERROR-STATUS p2j handle, that can contain supressed errors
information in case of NO-ERROR expression used in P4GL statement.
|
| ErrorManager.ServerErrorDataAccessor |
Provides access to the error data.
|
| ErrorManager.SuppressedErrorDataAccessor |
Process errors with ignore.
|
| ErrorManager.WorkArea |
Stores global data relating to the state of the current context's
transactions.
|
| ExplicitFileList |
Creates a sorted list of files based on a user-defined list of filenames
(absolute or relative).
|
| ExportCert |
Export the certificate and its private key from the directory.
|
| ExportField |
Handles export formatted output of data fields for I/O helpers.
|
| ExportFieldExpansion |
TODO: finish this implementation
TODO: table extent field support?
|
| ExpressionWrapper |
A convenience adapter class to create a Resolvable runtime
expression from an instance of an Accessor. |
| ExternalProgramWrapper |
This container adds support for all persistent-procedure related attributes
and methods, such as:
INTERNAL-ENTRIES
NAME
FILE-NAME
PERSISTENT
TYPE
NEXT-SIBLING
PREV-SIBLING
PRIVATE-DATA
GET-SIGNATURE
ADD-SUPER-PROCEDURE
REMOVE-SUPER-PROCEDURE
SUPER-PROCEDURES
SERVER
SINGLE-RUN
SINGLETON
ASYNC-REQUEST-COUNT
INSTANTIATING-PROCEDURE
CURRENT-WINDOW
|
| ExternalResource |
Instances of this class are helpers to associate a surrogate handle ID with a resource on a
remote side.
|
| FallbackEnvironmentReader |
Fallback Environment Reader
|
| FieldAssigner |
Specialization of OutputParameterAssigner that handles various *Field data-type
wrapper implementations, which assigns an INPUT-OUTPUT or OUTPUT parameter's value back to the
database field with which it is associated, upon exit from a procedure or function. |
| FieldEntry |
This class provides an abstract base for passing data lists to I/O helpers.
|
| FileChecker |
Utility class that uses JNI call to get the bitfield representing the
status type of the given file path parameter and return the equivalent
Progress OS-DIR status.
|
| FileInfo |
Provides a container to store/transfer file attributes as defined by the
Progress FILE-INFO system handle.
|
| FileList |
Creates a sorted list of files that can be accessed as either an array
of filenames (strings) or as an array of File objects.
|
| FileListFactory |
Static helpers to create file lists.
|
| FileSpecList |
Creates a sorted list of files in the current directory or a user-defined
start directory that match a user-defined specification (including
wildcards).
|
| FileStream |
A stream class supporting input and output semantics for any file-like
file system object (file or device).
|
| FileSystemOps |
Progress compatible static file-system utility methods.
|
| FileSystemOps.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| FileSystemOps.WorkArea |
Stores global data relating to the state of the current context.
|
| FinalParameterContainer<T> |
Objects of this class are used when a non-final object which must be accessed from a lambda/inner class.
|
| FuzzyMethodRt |
Implements the rules to perform fuzzy method lookup, for runtime.
|
| FuzzyMethodRt.InternalMethodData |
|
| FWDDataObject |
Proxy wrapper for a DataObject instance.
|
| GenericExpression |
|
| GUIPrinterStreamSupport |
The class implements all the necessary logic behind the GUI printer streams and servers as the
core of the runtime support of the 4GL statement OUTPUT TO PRINTER.
|
| handle |
A class that represents a Progress 4GL compatible handle data type.
|
| handle.DummyResource |
A pseudo-resource with a set id.
|
| handle.Helper |
Helper to expose APIs which have direct access to the context-local state.
|
| handle.InvalidAttributeAccess |
|
| handle.WorkArea |
Stores global data relating to the state of the current context.
|
| HandleChain |
This acts as a superclass which implements the most common methods of the
CommonHandleChain interface:
attribute or base method
API
NAME
HandleChain.name()
PREV-SIBLING
HandleChain.getPrevSibling()
NEXT-SIBLING
HandleChain.getNextSibling()
PRIVATE-DATA
HandleChain.getPrivateData(), HandleChain.setPrivateData(character) and
HandleChain.setPrivateData(String)
| HandleChain.WorkArea |
Stores global data relating to the state of the current context.
|
| HandleFieldRef |
Data wrapper which associates with a DMO property and provides direct access to this property.
|
| HandleOps |
Provides implementation for these handle-specific operations:
DELETE OBJECT
DELETE PROCEDURE
CAN-QUERY() built-in function
CAN-SET() built-in function
Current implementation provides support only for SESSION, FILE-INFO,
LAST-EVENT, ERROR-STATUS and procedure handles.
|
| HandlePropertyRef |
Data wrapper which associates with a OO property and provides direct access to this property.
|
| HandleResource |
This acts as a superclass which implements:
attribute or base method
API
TYPE
HandleResource.resourceType() and HandleResource.type()
INSTANTIATING-PROCEDURE
HandleResource.instantiatingProcedure()
Unknown status
HandleResource.unknown()
Read only field error
HandleResource.readOnlyError(String, Object)
Invalid attribute access
HandleResource.invalidAttribute(String, boolean)
| I18nOps |
Progress compatible I18N-related environment static utility methods.
|
| I18nOps.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| I18nOps.WorkArea |
Stores global data relating to the state of the current context.
|
| I18nString |
Holder for translatable string.
|
| ImportFieldExpansion |
TODO: finish this implementation
TODO: table extent field support?
|
| IndexedAccessor |
Accessor that stores the index of the requested array element.
|
| InputOutputExtentField<T extends BaseDataType> |
Data wrapper which associates with a DMO extent property.
|
| InputOutputExtentParameter<T extends BaseDataType> |
Special wrapper used for variables passed as input-output extent parameters to
functions or procedures.
|
| InputOutputTableHandle |
Implements the INPUT-OUTPUT TABLE-HANDLE parameter type.
|
| InputOutputTableParameter |
Implements the INPUT-OUTPUT TABLE parameter type.
|
| InputParameter |
Defines APIs emitted to preserve the conversion-time type of an expression, and allow the runtime to check
if the evaluated value of this expression matches the conversion-time type or not.
|
| InputStreamWrapper |
Provides a Java InputStream which accesses a contained
Stream instance. |
| InputTableHandle |
Implements the INPUT TABLE-HANDLE parameter type.
|
| InputTableParameter |
Implements the INPUT TABLE parameter type.
|
| int64 |
A class that represents a Progress 4GL compatible 64-bit integer object whose data is mutable.
|
| int64.ContextContainer |
Simple container that stores and returns a context-local instance of the global work area.
|
| int64.WorkArea |
Stores global data relating to the state of the current context.
|
| Int64Expression |
A convenience adapter class for a Resolvable runtime expression
which must return an int64 result. |
| integer |
A class that represents a Progress 4GL compatible integer object whose
data is mutable.
|
| IntegerExpression |
A convenience adapter class for a Resolvable runtime expression
which must return an integer result. |
| InternalEntry |
Container for legacy info belonging to an internal entry (a user-defined internal procedure,
function or external API call).
|
| InterruptedExceptionHandler |
The InterruptedException handler that simply converts it into the Progress-
like StopConditionException.
|
| InvocationRequestPayload |
This payload is responsible for defining the details of a call into 4GL code, originating from
a customer-specific application (used in cases when the client runs in an embedded mode, inside
another application).
|
| InvocationResponsePayload |
This class holds the data for a response, after invoking a 4GL external program, procedure or
function, and associated with a request incoming from a customer-specific application.
|
| InvokeConfig |
Defines a configuration which can be used by a RUN or dynamic function call.
|
| Iterables |
Set of helper methods for iterables.
|
| Iterables.RevIterable<T> |
Reverse iterable implementation.
|
| JarUtil |
Utility methods for jar files.
|
| JarUtil.JarResource |
Object returned by a search for a resource in a jar file.
|
| JavaInvokeConfig |
Defines a configuration which can be used to invoke Java methods on the appserver.
|
| jobject<T> |
Wrapper class for all Java instances accessed from legacy 4GL code.
|
| KeyReader |
Provides Progress compatible helper methods to manage reading a key/char
and accessing the last key read.
|
| KeyReader.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| KeyReader.WorkArea |
Stores data relating to the state of the current context's key reading.
|
| LaunchManager |
External program launch manager which properly handles terminal state
during program execution.
|
| LazyUndoable |
Defines behaviour for objects which can be rolled back at runtime.
|
| LegacyDsLogManagerImpl |
Implementation for the DSLOG-MANAGER system handles.
|
| LegacyFieldMetaData |
Helper class to provide details about a field's metadata.
|
| LegacyJavaAppserver |
The legacy Java Open Client for appserver relies on Tuscany SDO to create an in-memory DataSet.
|
| LegacyJavaAppserverClient |
Provides helper APIs to interact with the Appserver running in the same FWD server.
|
| LegacyJavaAppserverClientProxy |
Base class for legacy open client proxy programs.
|
| LegacyJavaAppserverParameter |
Parameter configuration when used by a remote side, as a replace for JavaOpenClient API.
|
| LegacyJavaAppserverProxyInvocationResult |
Allow access to the RETURN-VALUE and OUTPUT/INPUT-OUTPUT arguments, after an invocation of a remote program.
|
| LegacyLogManagerClientServiceImpl |
LOG-MANAGER client service.
|
| LegacyLogManagerConfigs |
Data class to store all startup LOG-MANAGER configs.
|
| LegacyLogManagerImpl |
Implementation for the LOG-MANAGER system handle.
|
| LegacyLogManagerImpl.GenericFileName |
A class for generic file names.
|
| LegacyLogManagerImpl.SequencedFileName |
A parser for log file names including a sequence number for rotation.
|
| LegacyLogManagerImpl.SequencedFileNameMatcher |
A matcher for log file names including certain prefix, extension and sequence number for rotation.
|
| LegacyLogOps |
Factory to create and manage the LOG-MANAGER and DSLOG-MANAGER instances.
|
| LegacyLogOps.WorkArea |
Stores global data relating to the state of the current context.
|
| LegacyLogWriteExecutor |
A single point of executing legacy LOG-MANAGER file write actions.
|
| LegacyLogWriteExecutor.ExecutorsThreadFactory |
Private static class ExecutorsThreadFactory to provide meaningful names for threads used by the
executors.
|
| LegacyLogWriteExecutor.LegacyLogManagerQueueHolder |
Initialization on demand holder for LegacyLogManagerQueue singleton initialization.
|
| LegacyLogWriteExecutor.WriteCallable |
Private static class WriteCallable that extends Callable.
|
| LegacyObject |
Provides a transport mechanism of object instances over the network, for i.e. |
| LegacyObject.LegacyArray |
Serializable storage of a BDT array associated with a field.
|
| LegacyOpenClientCaller |
|
| LegacyOpenClientCaller.WorkArea |
Stores global data relating to the state of the current context.
|
| LegacyRelationMetaData |
Helper class to provide details about a relation's metadata.
|
| LineContent |
A class implementing the INI text file comment line or empty line.
|
| LoadCert |
Adds new or replaces existing certificates in the directory.
|
| LoadPrivateKey |
Adds new or replaces existing private keys in the directory.
|
| LobCopy |
Object which performs a large object (LOB) copy operation.
|
| LobCopyInput |
Abstract base class for an object that can be the input value to a converted COPY-LOB statement.
|
| LobCopyOutput |
Abstract base class for an object that can be the output value to a converted COPY-LOB
statement.
|
| logical |
A class that represents a Progress 4GL compatible logical object whose
data is mutable.
|
| logical.logicalConstant |
An immutable logical type, to be used for TRUE/FALSE/UNKNOWN singletons required within FWD runtime.
|
| LogicalExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a logical result. |
| LogicalExpressionConverter |
Conversion of the logical expression accepted by CONTAINS operator to the
Reverse Polish Notation(RPN), Conjunctive Normal Form (CNF), or Disjunctive Normal Form (DNF)
|
| LogicalExpressionConverter.Equals |
"Equals" predicate
|
| LogicalExpressionConverter.Lexer |
Lexer which builds a token stream from the match expression.
|
| LogicalExpressionConverter.Node |
Expresssion tree node
|
| LogicalExpressionConverter.StartsWith |
"StartsWith" predicate
|
| LogicalExpressionConverter.Term |
Base class for expression terms
|
| LogicalFormatParser |
Parse format for OE logical values.
|
| longchar |
A class that represents a Progress 4GL compatible longchar object whose data is mutable.
|
| LowLevelSocketListenerImpl |
This class acts as a delegate for the server-side to the create java socket.
|
| LowLevelSocketListenerImpl.ConnectListener |
Start a loop in a different thread and listen for incoming connections.
|
| LowLevelSocketListenerImpl.ServerSocketData |
Container of various server-socket related data.
|
| MathOps |
A class that provides Progress 4GL compatible math functions and arithmetic
operators.
|
| MaximumAccumulator |
An accumulator implementation which determines the maximum value from
among all values of a data source across all iterations of a loop, as well
as across the current break group within the loop.
|
| MemoryBuffer |
Provides a byte buffer to be used from non-P2J code, when performing remote appserver calls.
|
| MemoryManager |
Provides access to buffers implemented by platform-specific memory buffers instead of the
Java heap.
|
| memptr |
Implements the unique behavior of a Progress 4GL compatible MEMPTR data type
which is backed by a native platform memory buffer (instead of being allocated on the Java
heap).
|
| memptr.memptrPointer |
A data structure with the details about the 'pointer' referenced by this instance.
|
| memptr.WorkArea |
Container for context-local data.
|
| MetadataSecurityOps |
Implementation of user security functions of P4GL using the _User metadata from database.
|
| MethodInvoker |
Helper class to delegate execution of Method.invoke.
|
| MinimumAccumulator |
An accumulator implementation which determines the minimum value from
among all values of a data source across all iterations of a loop, as well
as across the current break group within the loop.
|
| MockLegacyJavaAppserverClient |
Mock the OpenClient APIs used to invoke a remote external program or internal procedure/function.
|
| NamedEventManager |
Provides a publish/subscribe mechanism for interprogram linkage.
|
| NativeAPIEmulation |
The class emulates native API calls.
|
| NativeAPIEmulation.windows |
Declares windows API symbols and supported libraries.
|
| NativeAPIEmulation.windows.advapi32 |
Declares supported advapi32.dll functions.
|
| NativeAPIEmulation.windows.kernel32 |
Declares supported kernel32.dll functions.
|
| NativeAPIEmulation.windows.user32 |
Declares supported user32.dll functions.
|
| NativeAPIEmulation.windows.wsock32 |
Declares supported wsock32.dll functions.
|
| NullField |
Outputs null characters to a stream.
|
| NullStream |
A stream class which represents a stream instance that is safe to call for
any processing but which is in actuality a no operation.
|
| NumberFormatParser |
Base class for Progress number format parsers/formatters.
|
| NumberFormatter |
Format Progress numbers.
|
| NumberType |
An abstract class that implements a Progress 4GL compatible numeric data
type.
|
| NumberType.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| NumberType.FormatSpec |
Serves as a container for parsed format specifications regarding
a specific Progress-compatible numeric format string.
|
| NumberType.WorkArea |
Stores global data relating to the state of the current context.
|
| object<T extends _BaseObject_> |
Wrapper class for all OO 4GL instance references.
|
| ObjectOps |
Defines APIs to manage 4GL-style objects (instantiation, deletion, cast, etc).
|
| ObjectOps.ObjectHelper |
Helper to expose APIs which have direct access to the context-local state.
|
| ObjectOps.WorkArea |
Context-local data.
|
| ObjectResource |
A pseudo-resource to help management for the legacy class instances.
|
| ObjectVar<T extends _BaseObject_> |
Wrapper class for all OO 4GL variable definitions.
|
| OnPhrase |
Represents the condition/action pair that defines how a given block is
configured to react to conditions.
|
| OutputExtentField<T extends BaseDataType> |
Data wrapper which associates with a DMO extent property.
|
| OutputExtentParameter<T extends BaseDataType> |
Special wrapper used for variables passed as output extent parameters to functions
or procedures.
|
| OutputParameter |
A utility class which associates a variable or DMO property with a data wrapper object.
|
| OutputStreamWrapper |
Provides an external OutputStream wrapper for a Stream. |
| OutputTableHandle |
Implements the OUTPUT TABLE-HANDLE parameter type.
|
| OutputTableParameter |
Implements the OUTPUT TABLE parameter type.
|
| Parameter |
Container for all info related to an internal-entry's InternalEntry parameter. |
| ParamFileReader |
-pf file helper
|
| ParsedDateFormat |
This centralizes 4GL date format parsing and provides public access to the parse results as
simple member fields.
|
| PartitionedArray<E> |
Maintains an ordered list with fast removal of partitions.
|
| PathResolverContainer |
Delegates the path resolution to the underlined path resolver and logs unresolved exception
as warnings.
|
| PathResolverImpl |
Resolves the legacy file system path to the path on the host system.
|
| PDFPageSetup |
Captures PDF options for PDF printing.
|
| PortTypeWrapper |
Implements a procedure connected to a WSDL port-type.
|
| PostInitErrorManager |
Stores errors as runnables to show them after the ErrorManager is fully initialized. |
| PrintOptions |
Container class for print options.
|
| ProcedureManager |
Provides implementation for the following procedure handles:
THIS-PROCEDURE
ProcedureManager.thisProcedure()
ProcedureManager.thisProcedure(Object)
SOURCE-PROCEDURE
ProcedureManager.sourceProcedure()
TARGET-PROCEDURE
ProcedureManager.targetProcedure()
The following procedure-related attributes and methods are implemented:
attribute or method
API
SESSION:SUPER-PROCEDURES
ProcedureManager.superProcedures()
SESSION:ADD-SUPER-PROCEDURE
ProcedureManager.addSuperProcedure(handle)
ProcedureManager.addSuperProcedure(handle, SearchMode)
ProcedureManager.addSuperProcedure(handle, int)
SESSION:REMOVE-SUPER-PROCEDURE
ProcedureManager.removeSuperProcedure(handle)
SESSION:FIRST-PROCEDURE
ProcedureManager.firstProcedure()
SESSION:LAST-PROCEDURE
ProcedureManager.lastProcedure()
| ProcedureManager.CalleeInfoImpl |
|
| ProcedureManager.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| ProcedureManager.ExternalSubscription |
|
| ProcedureManager.GlobalEventSubscriptions |
Helper class to manage the global subscriptions.
|
| ProcedureManager.LegacySubscription |
Contains data about a legacy subscription made by a certain procedure.
|
| ProcedureManager.ProcedureData |
Container for various procedure data.
|
| ProcedureManager.ProcedureHelper |
Helper to expose APIs which have direct access to the context-local state.
|
| ProcedureManager.PublishTask |
Container for a PUBLISH task to be executed in the actual subscription's context.
|
| ProcedureManager.Subscription<T> |
Contains data about a subscription.
|
| ProcedureManager.WorkArea |
Stores global data relating to the state of the current context.
|
| ProcessDaemon |
Provides 2 forms of process launching:
|
| ProcessOps |
Provides static utility methods for Progress 4GL compatible process
launching and control.
|
| ProcessOps.CommandLineParser |
Gets a supported helper application parameter from the given command arguments list.
|
| ProcessOps.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| ProcessOps.WorkArea |
Stores global data relating to the state of the current context.
|
| ProcessStream |
A stream class supporting input and output semantics for the
STDIO pipes of a child process.
|
| ProfilerUtils |
This class provides implementation for PROFILER attributes and methods.
|
| ProfilerUtils.WorkArea |
Stores global data relating to the state of the current context.
|
| PropertyReference |
Dynamic access to a legacy property.
|
| ProtectedTimer |
A timer facility which protects against out-of-memory errors.
|
| ProtectedTimerTask |
A task that can be scheduled for one-time or repeated execution by a ProtectedTimer. |
| ProxyProcedureWrapper |
This class implements the proxy procedure resource; on the requester side, this resource is
linked with a remote procedure resource from the remote, appserver, side.
|
| PutField |
Handles output of data fields for I/O helpers.
|
| PutFieldExpansion |
TODO: finish this implementation
TODO: table extent field support?
|
| Quoter |
A class implementation of the Progress QUOTER utility.
|
| Quoter.ColumnRange |
Utility class to handle column ranges
|
| raw |
A class that implements common services for a Progress 4GL compatible raw data type whose data
is mutable.
|
| RawExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a raw result. |
| RcodeInfoOps |
Utility for working with RCODE-INFO system handle that lets you read information about r-code files.
|
| RcodeInfoOps.LegacyProgramInfo |
Details about the r-code information for a legacy program or class.
|
| RcodeInfoOps.WorkArea |
Stores global data relating to the state of the current context.
|
| recid |
A class that represents a Progress 4GL compatible record ID.
|
| RecidExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a recid result. |
| ReflectionHelper |
Utility methods to ease or replace use of J2SE reflection.
|
| Registry |
A class implementing the Windows registry based environment methods.
|
| RemoteLegacyJavaAppserverClient |
A Java client which connected to a remote FWD server.
|
| RemoteResourceImpl |
This implementation is used to either transport resource IDs during appserver calls from one
side to another or, on requester side, to identify a resource as being remote.
|
| RemoteStream |
A stream class which represents a stream instance that is on a remote node
and which redirects all local method calls into operations to that
instance.
|
| RemoteStream.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| RemoteStream.WorkArea |
Stores global data relating to the state of the current context.
|
| ResourceIdHelper |
|
| rowid |
A class that represents a Progress 4GL compatible rowid data type.
|
| RowidExpression |
A convenience adapter class for a Resolvable runtime expression
which must return a rowid result. |
| ScopedDictionary<K,V> |
Implements a symbol dictionary with multiple levels of scope.
|
| ScopedDictionary.Node<K,V> |
Represents complex items on the stack of scopes.
|
| ScopedList<E> |
A linked list implementation which is organized into scopes, each representing a sub-list of
elements.
|
| ScopedList.Node<E> |
A node in the list.
|
| ScopedSymbolDictionary<V> |
Implements a symbol dictionary with multiple levels of scope.
|
| SectionContent |
A class implementing the INI text file key=value section lines.
|
| SectionContent.KeyRenderer |
The class to present key-value pair in one ordered list.
|
| SectionContent.TextRenderer |
The class to present single line in one ordered list.
|
| SecurityManagerSecurityOps |
Progress 4GL compatible security interface that does not use the _User meta-table.
|
| SecurityOps |
Provides static utility methods for Progress 4GL compatible security
functions.
|
| SecurityOps.Domain |
This defines the configuration of a security domain, with state taken from the 4GL legacy
_sec-authentication-domain.d system table.
|
| SecurityOps.DomainType |
This defines the configuration of a security domain, with state taken from the 4GL legacy
_sec-authentication-system.d system table.
|
| SecurityOps.QUserId |
Qualified user id.
|
| SecurityOps.WorkArea |
Stores context-local state related to security.
|
| SecurityPolicyManager |
Provides static methods implementing support for the SECURITY-POLICY system
handle attributes and methods See CommonSecurityPolicy |
| SecurityPolicyManager.DomainRegistry |
Domain registry.
|
| SecurityPolicyManager.PersistentDomain |
Domain loaded from the connected permanent database.
|
| SecurityPolicyManager.RuntimeDomain |
Runtime security domain.
|
| SecurityPolicyManager.WorkArea |
Stores global data relating to the state of the current context.
|
| SelfManager |
This class manages scoping of the SELF system handle.
|
| SelfManager.WorkArea |
Container of context-local data.
|
| SensitiveResource |
|
| ServerConnectHelper |
This is a helper class to bring to central point the options which can be passed to a connect
like methods.
|
| ServerFactory |
A class for instantiating server handles.
|
| ServerHelper |
Defines common APIs used by a server connected to either an appserver or a web service.
|
| ServerImpl |
A class for implementing APPSERVER methods and attributes.
|
| ServerPropertiesDaemon |
Implements ServerPropertiesInspector, describing methods for the server-side to get different
system property and running mode values. |
| SessionDateUtils |
This class provides implementation for SESSION date-related attributes.
|
| SessionForkManager |
Manager for forking sessions in web
|
| SessionForkManager.ForkedSessionConfigs |
Class for client configs necessary for replicating the original session
|
| SessionForkManager.SingletonHolder |
Initialization on demand idiom singleton holder
|
| SessionUtils |
This class provides implementation for SESSION attributes and methods.
|
| SessionUtils.WorkArea |
Stores global data relating to the state of the current context.
|
| SharedVariableManager |
Provides context-local scoped variable, stream, buffer, frame and temp
table pools.
|
| SharedVariableManager.BufferRegistry |
A registry for BUFFER resources.
|
| SharedVariableManager.PersistentRegistry |
A registry for resources which exist with the persistent procedure.
|
| SharedVariableManager.PersistentShares<T extends SharedVariableManager.PersistentRegistry> |
Common behavior for all shared resources which are in sync with the persistent procedure
state.
|
| SharedVariableManager.SharedRegistry |
Stores the registry for a specified shared resource.
|
| SharedVariableManager.VarRegistry |
Container for the registries related to shared variables.
|
| SharedVariableManager.WorkArea |
Stores the state of the current context.
|
| SkipField |
Outputs new lines to a stream.
|
| SOAPFactory |
|
| SOAPFaultDetailImpl |
A class for implementing the SOAP-FAULT-DETAIL method and attributes.
|
| SOAPFaultImpl |
A class for implementing the SOAP-FAULT method and attributes.
|
| SOAPHeaderEntryImpl |
A class for implementing the SOAP-HEADER-ENTRYREF methods and attributes.
|
| SOAPHeaderImpl |
A class for implementing the SOAP-HEADER methods and attributes.
|
| SocketFactory |
A class for instantiating socket handles.
|
| SocketImpl |
A class for implementing the SOCKET method and attributes.
|
| SocketImpl.ServerSocketMapping |
Mapping of a legacy server socket data to post-migration server socket.
|
| SocketImpl.WorkArea |
Container for context-local state.
|
| SocketListenerImpl |
A class for implementing the SERVER-SOCKET method and attributes.
|
| SourceLob |
Concrete implementation of a converted COPY-LOB source parameter, corresponding with the
FROM [ OBJECT ] source-lob phrase.
|
| SourceLobFile |
An object which represents a client-side file which is the source of a converted COPY-LOB statement.
|
| SourceNameMapper |
This class performs a bidirectional run-time mapping of a Progress
procedure file name to and from a Java class name.
|
| SourceNameMapper.ExternalProgram |
Container for all external program information.
|
| SourceNameMapper.InternalEntryKey |
Map key for internal entry objects.
|
| SourceNameMapper.LegacyClass |
Container for all legacy class information.
|
| SourceNameMapper.MonitorRunnable |
|
| SourceNameMapper.MultiPathLookup |
A lookup class which stores multiple SinglePathLookup instances.
|
| SourceNameMapper.SinglePathLookup |
A lookup class which stores possible paths of a program and can be used to retrieve
the same ExternalProgram for each of those paths.
|
| SourceNameMapper.SourceNameMapperCache |
|
| SourceNameMapper.SourceThreadFactory |
A thread factory class that is used to create AssociatedThread(s) for creating source cache entries.
|
| SourceNameMapper.WorkArea |
Container for context-local data.
|
| SpaceField |
Outputs spaces to a stream.
|
| SQLHelper |
Static class that exposes utility methods for processing strings that are fed to SQL queries as
part of WHERE clauses.
|
| StaleProcedureManager |
Enclosing several methods for working with stale referents.
|
| StaleProcedureManager.WorkArea |
Stores global data relating to the state of the current context.
|
| StanzaIni |
A class implementing the INI file based environment methods.
|
| StopAfterTimer |
Provides runtime support for stop-after statement for blocks
doBlock, forBlock, repeatBlock.
|
| Stream |
A stream class supporting methods for the Progress-compatible reading and
writing as well as facilities for line and page processing.
|
| StreamDaemon |
Provides a network interface for stream creation and stream operations which are remote.
|
| StreamFactory |
Creates file and process stream instances that are on the remote node associated with the current user's
session and which are accessed via a RemoteStream instance. |
| StreamFactory.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| StreamFactory.WorkArea |
Stores global data relating to the state of the current context.
|
| StreamWrapper |
A stream class which acts as a container which redirects any stream
method call to the contained stream reference.
|
| StreamWrapper.WorkArea |
Context-local data.
|
| SupplierWithMemo<T> |
Adds caching functionality to the given supplier.
|
| SystemHandleBase |
Provides implementation of the {link CommonHandle} methods
can be used as base class for system handles (such as SECURITY-POLICY}
runtime support
|
| TableParameter |
Represents a table or table-handle parameter, the mode (INPUT, INPUT-OUTPUT or OUTPUT) and any table
parameter options (APPEND, BY-VALUE, BIND or BY-REFERENCE).
|
| TailHashMap<K,V> |
A dictionary that supports registering new items in a
new Map tail while iterating the collection.
|
| TailIdentityHashMap<K,V> |
A dictionary that supports registering new items in a
new Map tail while iterating the collection.
|
| TailMapAutoClosable<K,V> |
Lightweight AutoCloseable object for try block.
|
| TailScopedDictionary<K,V> |
|
| TailScopedDictionary.EmptyTailMap<K,V> |
An immutable empty static subclass of TailHashMap.
|
| TargetLob |
Concrete implementation of a converted COPY-LOB target parameter, corresponding with the
TO [ OBJECT ] target-lob phrase.
|
| TargetLobFile |
Concrete implementation of a converted COPY-LOB target parameter, corresponding with the
TO FILE target-filename [ APPEND ] phrase.
|
| TemplateHelper |
Defines helper static methods to fill templates with provided values.
|
| TerminalStream |
This class provides support for stream redirected to the interactive
terminal.
|
| Text |
|
| TextOps |
A class that provides Progress 4GL compatible character and longchar
functions and operators.
|
| ThreadSafeQueue<E> |
This class implements a thread safe queue of the objects.
|
| ThreadSafeQueue.Poison |
Class for the termination token
|
| ToClause |
Represents an incrementing or decrementing loop construct that can be
passed to the block manager allowing a loop to be implemented on a
delegated basis.
|
| TotalAccumulator |
A summation accumulator implementation which maintains a running, numeric
total across all iterations of a loop, as well as across the current break
group.
|
| TraceHelper |
Helper methods to trace method invocations.
|
| TransactionImpl |
Implements the TRANSACTION resources and all associated APIs.
|
| TransactionImpl.WorkArea |
Context-local state.
|
| TransactionManager |
Progress compatible transaction/block properties static utility methods
which operate upon a context-local scoped dictionary of blocks.
|
| TransactionManager.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| TransactionManager.DbTransactions |
The transaction information for a database.
|
| TransactionManager.TransactionHelper |
Helper to expose transaction state in a way that avoids context local lookups.
|
| TransactionManager.UndoableHelper |
Helper class to expose context-local state for undoable support.
|
| TransactionManager.WorkArea |
Stores global data relating to the state of the current context's
transactions.
|
| TranslationManager |
Implements internationalization tasks, i.e.
|
| TranslationManager.BundleControl |
Custom bundle control to override the bundle name logic.
|
| TransparentWrapper |
Simple container that stores an object instance and implements the
WrappedResource interface. |
| TreeNode |
A tree node which is a base class which provides a simple mechanism to
create and use trees to store custom data.
|
| Trigger |
Base class for all trigger blocks.
|
| TriggerDefinition |
Container for trigger metadata that allows a new instance to be
manufactured.
|
| Tuple<T,P> |
Generic data structure for two values, for convenience called key and value.
|
| TypeFactory |
Provides APIs to create or initialize or 4GL-compatbile instance.
|
| UndoableFactory |
Provides APIs to create or initialize an undoable instance and register for undoable support.
|
| UndoablePair |
Simple association between an LazyUndoable and a copy of that
LazyUndoable.
|
| UnformattedPayload |
|
| UnimplementedFeature |
Helper class to cleanly log runtime usage of code that is unimplemented or partial.
|
| UniqueIdGenerator |
Generator for ids used as UNIQUE-ID attribute values.
|
| unknown |
A class that represents a Progress 4GL compatible unknown value literal.
|
| UnnamedStreams |
Stores state and provides functional support for the unnamed in and unnamed out streams.
|
| UnnamedStreams.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| UnnamedStreams.InputCloser |
Finalizable class which will perform a closeIn call only if this class
is in the top of the closerIn stack - this way we make sure there are
not possible two subsequent calls to the closeIn statement.
|
| UnnamedStreams.OutputCloser |
Finalizable class which will perform a closeOut call only if this class
is in the top of the closerOut stack - this way we make sure there are
not possible two subsequent calls to the closeOut statement.
|
| UnnamedStreams.WorkArea |
Stores global data relating to the state of the current context.
|
| Utils |
Collection of useful, static, utility methods for various tasks.
|
| Utils.ContextContainer |
Simple container that stores and returns a context-local instance of
the global work area.
|
| Utils.DirectoryHelper |
Provides a simple unified API for delegating the querying of a
data type-specific value from the directory.
|
| Utils.InstrumentedMap<K,V> |
Utility class extending HashMap functionality
|
| Utils.MethodData |
|
| Utils.WorkArea |
Stores global data relating to the state of the current context.
|
| Utils.ZKey |
Auxiliary class for use on the normalizeOrder method
|
| VariableAssigner |
Specialization of OutputParameterAssigner that handles intermediary variables are
replacement of the correct type that assign INPUT-OUTPUT or OUTPUT parameter's value back to
the database field with which it is associated, upon exit from a procedure or function. |
| WeakList<E> |
A wrapper for a linked list of weak references.
|
| WebBrowserManager |
Manage to open web pages in the browser's window.
|
| WebContextOps |
Utility for working with WEB-CONTEXT system handle.
|
| WebContextOps.WorkArea |
Stores global data relating to the state of the current context.
|
| WebHelper |
Provides helper methods for web integration.
|
| WebServiceConnectOptions |
Container for various web-service connect options.
|
| WebServiceHelper |
Provides a collection of APIs for establishing Progress-style connections to web-services and
performing Progress-style invocation of service operations.
|
| WidgetPool |
Widget-pool management class.
|
| WidgetPool.WidgetPoolData |
The data needed for a widget pool, named or unnamed.
|
| WidgetPool.WidgetPoolHelper |
Helper to expose APIs which have direct access to the context-local state.
|
| WidgetPool.WorkArea |
Container for the widget-pool data.
|
Annotation Types Summary
| Annotation Type |
Description |
| DatabaseReferences |
Annotation used to specify the list of logical database names or aliases (without the _temp database).
|
| LegacyAttribute |
Annotation definition to mark methods as the replacements for Progress 4GL attributes.
|
| LegacyMethod |
Annotation definition to mark methods as the replacements for Progress 4GL methods.
|
| LegacyParameter |
Specification for a legacy parameter definition.
|
| LegacyResource |
Annotation definition to mark the Progress 4GL resource type implemented by a P2J
class.
|
| LegacyResourceSupport |
Annotation definition to mark the Progress 4GL resource type level of support.
|
| LegacySerializable |
This annotation is used to mark legacy OO classes as serializable (the SERIALIZABLE option at the
class definition).
|
| LegacyService |
This annotation is used to mark a Java method as a legacy service.
|
| LegacyServiceParameter |
|
| LegacyServices |
|
| LegacySignature |
Annotation used to record the legacy signature for OO methods and class events.
|
| LegacyWebPath |
|
| LoadLegacyClass |
Annotation used to mark legacy class fields which must trigger the loading of this legacy class (within
the FWD context) before accessing the field.
|
| ResourceType |
This annotation is used to mark methods with return type handle to denote the actual resource
type held by the returned handle.
|
| SchemaTrigger |
Annotation definition to mark trigger trigger procedures in order to be dynamically
found and loaded at runtime.
|
Package com.goldencode.p2j.util Description
Provides various helper classes to handle standard tasks related to
strings, XML files, symbol resolution, tree walking and more.
Author
|
Greg Shah
|
Date
|
November 30, 2004
|
Access Control
|
CONFIDENTIAL
|
Copyright (c) 2004, Golden Code
Development Corporation.
ALL RIGHTS RESERVED. Use is subject to license terms.
Copyright (c) 2004-2023, Golden Code Development Corporation.
ALL RIGHTS RESERVED. Use is subject to license terms.
| | |