ProcedureManager.WorkArea (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.util.ProcedureManager.WorkArea

All Implemented Interfaces:

Initializable, Scopeable

Enclosing class:

ProcedureManager
```
private static class ProcedureManager.WorkArea
extends java.lang.Object
implements Initializable, Scopeable
```
Stores global data relating to the state of the current context.

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.ArrayDeque<ProcedureManager.CalleeInfoImpl>`	`calleeInfo` A stack containing the info about the next called program or internal entry.
`private java.util.ArrayDeque<java.util.List<java.lang.Runnable>[]>`	`cleanupHandlers` Stack with output parameter handlers to be processed on procedure's return.
`private java.util.Map<java.lang.String,java.util.Set<java.lang.String>>`	`defaultDbs` The default databases for each java package prefix.
`private java.util.IdentityHashMap<java.lang.Object,java.lang.Boolean>`	`deleteOnExit` Map with flags indicating if this procedure should be deleted on exit.
`private static java.util.LinkedList<java.lang.Runnable>[]`	`EMPTY_SCOPE_STACK` An immutable marker for UNUSED stack of cleanup handlers for a scope.
`private ErrorManager.ErrorHelper`	`errHelper` Helper to use the `ErrorManager` without any context local lookups.
`private handle.Helper`	`h` Helper to use the `handle` without any context local lookups.
`private java.lang.String`	`initiatingExtProg` The 4GL program name being currently initiating.
`private java.lang.Class<?>`	`initiatingExtProgClass` The Java class for the current external program or OE class being executed.
`private java.util.ArrayDeque<java.lang.String>`	`internalEntryStack` Stack of internal entry names.
`private ObjectOps.ObjectHelper`	`oh` Helper to use the `ObjectOps` without any context local lookups.
`private WrappedResource`	`pendingResourceDelete` The resource currently being deleted.
`private java.util.LinkedHashSet<WrappedResource>`	`pendingResources` Resources pending to registered with THIS-PROCEDURE when the next block is entered.
`private FastSiblingDeque<java.lang.Object>`	`persistentProcedures` The list of all registered persistent procedures, via RUN PERSISTENT calls.
`private java.util.IdentityHashMap<java.lang.Object,Stack<BlockDefinition>>`	`persistentProcStacks` This will store the a snapshot of the block stack when the first global buffer was used.
`private java.util.IdentityHashMap<java.lang.Object,ProcedureManager.ProcedureData>`	`pMap` This map holds the attributes for all registered external procedures, by instance.
`private java.lang.Object`	`processedProcedure` Indicates the current external program when a scope or finalizable notification occurs.
`private java.lang.Object`	`publishSourceProcedure` Explicit referent used as SOURCE-PROCEDURE for a PUBLISH statement.
`private boolean`	`registerPendingResources` Flag indicating if static resources can be added to `pendingResources`.
`private java.util.IdentityHashMap<java.lang.Object,java.lang.String>`	`relativeNames` Map of relative names (i.e.
`private java.util.Set<java.lang.Object>`	`remotePersistentProcedures` A registry of persistent procedures which were instantiated by a remote side.
`private java.util.LinkedHashMap<java.lang.Object,ProcedureManager.ProcedureData>`	`sessionSuperProcs` A map containing the list of super-procedures, for the session, by each instance.
`private java.util.IdentityHashMap<java.lang.Class<?>,java.lang.Object>`	`singletonMap` This map holds all the singleton instances in this context.
`private java.util.ArrayDeque<ProcedureManager.ProcedureData>`	`sourceProceduresData` Stack of source-procedures' data.
`java.util.Set<java.lang.Object>`	`staleProcedures` A set of persistent procedures which were deleted but are in a state that allow them to be deleted again
`private java.util.LinkedList<ProcedureManager.Subscription>`	`subscriptions` The global list of subscriptions, for this context.
`private java.util.HashMap<character,java.util.LinkedList<ProcedureManager.Subscription>>`	`subscriptionsByEvent` Per-event subscribes, to avoid iterating all subscriptions when performing a PUBLISH.
`private java.util.ArrayDeque<ProcedureManager.ProcedureData>`	`targetProceduresData` Stack of target-procedures' data.
`private java.util.ArrayDeque<ProcedureManager.ProcedureData>`	`thisProceduresData` Stack of this-procedures' data.
`private TransactionManager.TransactionHelper`	`tm` Helper to use the TM without any context local lookups.
`private WidgetPool.WidgetPoolHelper`	`wp` Helper to use the `WidgetPool` without any context local lookups.

Constructor Summary

Constructors
Modifier Constructor and Description

private WorkArea()

Constructors
Modifier	Constructor and Description
`private`	`WorkArea()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addPersistentProcStack(java.lang.Object referent, Stack<BlockDefinition> stack)` Adds a block stack snapshot to the persistent procedure stacks.
`boolean`	`addStaleReferent(java.lang.Object referent)` Marks the specified referent as stale.
`void`	`cleanup(java.lang.Object referent)` Attempt cleanup of the given external program instance.
`private java.util.Iterator<java.lang.Object>`	`destinationIterator()` Get an iterator over the stack of destination resolved code.
`private java.util.Iterator<java.lang.Class<?>>`	`executingIterator()` Get an iterator over the stack of currently executing code.
`void`	`forceCleanup(java.lang.Object referent)` Cleanup of the given external program instance.
`private java.lang.Class<?>`	`getExecuting()` Get the Java class associated with the currently executing code.
`Stack<BlockDefinition>`	`getPersistentProcStack(java.lang.Object referent)` Obtains the stack snapshot of one persistent procedure.
`ScopeId`	`getScopeId()` Get the `ScopeId` for the instance.
`java.util.Map<java.lang.Object,ProcedureManager.ProcedureData>`	`getSessionSuperProcedures()` Get the map of session's super-procedures.
`java.lang.String`	`getStackEntry(int idx)` Implementation for the PROGRAM-NAME functions.
`java.util.Map<java.lang.Object,ProcedureManager.ProcedureData>`	`getSuperProcedures(java.lang.Object referent, boolean readOnly)` Get the map of the super-procedures for the given referent.
`boolean`	`hasPersistentProcStack(java.lang.Object referent)` Check if a referent is persistent and has a stack attached.
`void`	`init()` Initialize this instance - read the `default-databases` configuration.
`boolean`	`isRemotePersistentProcedure(java.lang.Object referent)` Check if an external program was ran persistent by a remote side.
`void`	`removeStaleProcedure(java.lang.Object referent)` Removes the referent information from the persistent procedure stack mapping.
`void`	`scopeDeleted()` Provides a notification that an external scope is about to be deleted.
`void`	`scopeFinished()` Handle scope notifications, to maintain proper source, target, and this-procedure references.
`void`	`scopeStart(BlockDefinition block)` Handle scope notifications, to maintain proper source, target, and this-procedure references.
`java.lang.Object`	`searchInStack(java.util.function.Function<java.lang.Object,java.lang.Object> search)` Walk the `THIS-PROCEDURE` stack and apply the search function; return the first value given by the search function, once it returns a non-null value.
`void`	`setInstantingExternalProgram(java.lang.String name)` Set the name of the 4GL program currently being instantiated, into the `initiatingExtProg` field.
`void`	`setInstantingExternalProgramClass(java.lang.Class<?> cls)` Set the Java class of the currently instantiating external program or OE class.
`private boolean`	`superProcForExtProc(java.lang.Object referent, java.util.Collection<java.lang.Object> progs)` Check if the given referent is a super-procedure of one of the procedures in the given list.

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

- Field Detail
  - defaultDbs
```
private java.util.Map<java.lang.String,java.util.Set<java.lang.String>> defaultDbs
```
    The default databases for each java package prefix.
  - tm
```
private TransactionManager.TransactionHelper tm
```
    Helper to use the TM without any context local lookups.
  - wp
```
private WidgetPool.WidgetPoolHelper wp
```
    Helper to use the WidgetPool without any context local lookups.
  - errHelper
```
private ErrorManager.ErrorHelper errHelper
```
    Helper to use the ErrorManager without any context local lookups.
  - h
```
private handle.Helper h
```
    Helper to use the handle without any context local lookups.
  - oh
```
private ObjectOps.ObjectHelper oh
```
    Helper to use the ObjectOps without any context local lookups.
  - persistentProcedures
```
private FastSiblingDeque<java.lang.Object> persistentProcedures
```
    The list of all registered persistent procedures, via RUN PERSISTENT calls.
  - sessionSuperProcs
```
private java.util.LinkedHashMap<java.lang.Object,ProcedureManager.ProcedureData> sessionSuperProcs
```
    A map containing the list of super-procedures, for the session, by each instance.
  - singletonMap
```
private java.util.IdentityHashMap<java.lang.Class<?>,java.lang.Object> singletonMap
```
    This map holds all the singleton instances in this context.
  - pMap
```
private java.util.IdentityHashMap<java.lang.Object,ProcedureManager.ProcedureData> pMap
```
    This map holds the attributes for all registered external procedures, by instance. It includes all persistent procedures and all procedures active on the stack.
  - targetProceduresData
```
private java.util.ArrayDeque<ProcedureManager.ProcedureData> targetProceduresData
```
    Stack of target-procedures' data. Must be kept in sync with targetProcedures! This stack holds procedure data for deleted TARGET-PROCEDURE handles.
  - sourceProceduresData
```
private java.util.ArrayDeque<ProcedureManager.ProcedureData> sourceProceduresData
```
    Stack of source-procedures' data. Must be kept in sync with sourceProcedures! This stack holds procedure data for deleted SOURCE-PROCEDURE handles.
  - thisProceduresData
```
private java.util.ArrayDeque<ProcedureManager.ProcedureData> thisProceduresData
```
    Stack of this-procedures' data. Must be kept in sync with thisProcedures!
  - cleanupHandlers
```
private final java.util.ArrayDeque<java.util.List<java.lang.Runnable>[]> cleanupHandlers
```
    Stack with output parameter handlers to be processed on procedure's return. Each scope is created using the EMPTY_SCOPE_STACK immutable object to avoid memory consumption due unused new objects. This will be replaced with a true stack at the moment of first usage. We use a deque/stack to enforce the order of execution of the cleanup handlers to be in reverse order, the LIFO order assuring the scope bracketing inside nested scopes.
  - EMPTY_SCOPE_STACK
```
private static final java.util.LinkedList<java.lang.Runnable>[] EMPTY_SCOPE_STACK
```
    An immutable marker for UNUSED stack of cleanup handlers for a scope.
  - publishSourceProcedure
```
private java.lang.Object publishSourceProcedure
```
    Explicit referent used as SOURCE-PROCEDURE for a PUBLISH statement.
  - internalEntryStack
```
private java.util.ArrayDeque<java.lang.String> internalEntryStack
```
    Stack of internal entry names. Evolves together with the #thisProcedures stack.
  - pendingResources
```
private java.util.LinkedHashSet<WrappedResource> pendingResources
```
    Resources pending to registered with THIS-PROCEDURE when the next block is entered.
  - registerPendingResources
```
private boolean registerPendingResources
```
    Flag indicating if static resources can be added to pendingResources.
  - relativeNames
```
private java.util.IdentityHashMap<java.lang.Object,java.lang.String> relativeNames
```
    Map of relative names (i.e. used at the RUN statement) for each external program.
  - processedProcedure
```
private java.lang.Object processedProcedure
```
    Indicates the current external program when a scope or finalizable notification occurs.
  - pendingResourceDelete
```
private WrappedResource pendingResourceDelete
```
    The resource currently being deleted.
  - calleeInfo
```
private java.util.ArrayDeque<ProcedureManager.CalleeInfoImpl> calleeInfo
```
    A stack containing the info about the next called program or internal entry.
  - initiatingExtProg
```
private java.lang.String initiatingExtProg
```
    The 4GL program name being currently initiating.
  - initiatingExtProgClass
```
private java.lang.Class<?> initiatingExtProgClass
```
    The Java class for the current external program or OE class being executed.
  - deleteOnExit
```
private java.util.IdentityHashMap<java.lang.Object,java.lang.Boolean> deleteOnExit
```
    Map with flags indicating if this procedure should be deleted on exit.
  - remotePersistentProcedures
```
private java.util.Set<java.lang.Object> remotePersistentProcedures
```
    A registry of persistent procedures which were instantiated by a remote side.
  - subscriptions
```
private java.util.LinkedList<ProcedureManager.Subscription> subscriptions
```
    The global list of subscriptions, for this context.
  - subscriptionsByEvent
```
private java.util.HashMap<character,java.util.LinkedList<ProcedureManager.Subscription>> subscriptionsByEvent
```
    Per-event subscribes, to avoid iterating all subscriptions when performing a PUBLISH.
  - persistentProcStacks
```
private java.util.IdentityHashMap<java.lang.Object,Stack<BlockDefinition>> persistentProcStacks
```
    This will store the a snapshot of the block stack when the first global buffer was used. This is used when a persistent procedure should be deleted: the delete will be postponed at a block on this stack.
  - staleProcedures
```
public java.util.Set<java.lang.Object> staleProcedures
```
    A set of persistent procedures which were deleted but are in a state that allow them to be deleted again
- Constructor Detail
  - WorkArea
```
private WorkArea()
```
- Method Detail
  - init
```
public void init()
```
    Initialize this instance - read the default-databases configuration.
    
    Specified by:
    
    init in interface Initializable
  - addPersistentProcStack
```
public void addPersistentProcStack(java.lang.Object referent,
                                   Stack<BlockDefinition> stack)
```
    Adds a block stack snapshot to the persistent procedure stacks. This is should be called when the stack shows the first time a global buffer in the referent is defined.
    
    Parameters:
    
    referent - The persistent procedure to which the stack is mapped.
    
    stack - The stack which should represent the current block stack snapshot.
  - hasPersistentProcStack
```
public boolean hasPersistentProcStack(java.lang.Object referent)
```
    Check if a referent is persistent and has a stack attached. If it has, it means that it opened a global static buffer at least once.
    
    Parameters:
    
    referent - The persistent procedure for which the checking is done.
    
    Returns:
    
    true if the referent has a persistent procedure stack attached.
  - getPersistentProcStack
```
public Stack<BlockDefinition> getPersistentProcStack(java.lang.Object referent)
```
    Obtains the stack snapshot of one persistent procedure. The stack represent the block stack when the first global buffer was defined inside the referent.
    
    Parameters:
    
    referent - The persistent procedure for which the stack should be retrieved.
    
    Returns:
    
    The block stack snapshot stored for the specified referent.
  - addStaleReferent
```
public boolean addStaleReferent(java.lang.Object referent)
```
    Marks the specified referent as stale.
    
    Parameters:
    
    referent - The referent which should be marked as stale.
    
    Returns:
    
    true if the provided referent was made stale for the first time.
  - removeStaleProcedure
```
public void removeStaleProcedure(java.lang.Object referent)
```
    Removes the referent information from the persistent procedure stack mapping. This should be done only when the referent is deleted (never be used again).
    
    Parameters:
    
    referent - The persistent procedure for which the entry should be removed.
  - searchInStack
```
public java.lang.Object searchInStack(java.util.function.Function<java.lang.Object,java.lang.Object> search)
```
    Walk the THIS-PROCEDURE stack and apply the search function; return the first value given by the search function, once it returns a non-null value.
    
    Parameters:
    
    search - The search function.
    
    Returns:
    
    The first non-null value returned by the search function.
  - setInstantingExternalProgram
```
public void setInstantingExternalProgram(java.lang.String name)
```
    Set the name of the 4GL program currently being instantiated, into the initiatingExtProg field.
    
    Parameters:
    
    name - The 4GL external program name.
  - setInstantingExternalProgramClass
```
public void setInstantingExternalProgramClass(java.lang.Class<?> cls)
```
    Set the Java class of the currently instantiating external program or OE class.
    
    Parameters:
    
    cls - The Java class for the currently executing code.
  - isRemotePersistentProcedure
```
public boolean isRemotePersistentProcedure(java.lang.Object referent)
```
    Check if an external program was ran persistent by a remote side.
    
    Parameters:
    
    referent - The external program instance.
    
    Returns:
    
    true if the referent is part of the remotePersistentProcedures map.
  - getStackEntry
```
public java.lang.String getStackEntry(int idx)
```
    Implementation for the PROGRAM-NAME functions. Resolves the legacy top level block (external program, function, internal procedure or trigger), at the given depth. The index starts with 0 for the currently executing top-level block.
    
    Parameters:
    
    idx - The stack entry index.
    
    Returns:
    
    The name of the stack entry or null if outside of stack.
  - scopeStart
```
public void scopeStart(BlockDefinition block)
```
    Handle scope notifications, to maintain proper source, target, and this-procedure references.
    
    Specified by:
    
    scopeStart in interface Scopeable
    
    Parameters:
    
    block - The explicit block definition which required this notification.
  - scopeFinished
```
public void scopeFinished()
```
    Handle scope notifications, to maintain proper source, target, and this-procedure references.
    
    Specified by:
    
    scopeFinished in interface Scopeable
  - scopeDeleted
```
public void scopeDeleted()
```
    Provides a notification that an external scope is about to be deleted.
    This implementation is a no-op.
    
    Specified by:
    
    scopeDeleted in interface Scopeable
  - getScopeId
```
public ScopeId getScopeId()
```
    Get the ScopeId for the instance.
    
    Specified by:
    
    getScopeId in interface Scopeable
    
    Returns:
    
    null, as the scope notification is done explicitly via TransactionManager.
  - getSessionSuperProcedures
```
public java.util.Map<java.lang.Object,ProcedureManager.ProcedureData> getSessionSuperProcedures()
```
    Get the map of session's super-procedures.
  - getSuperProcedures
```
public java.util.Map<java.lang.Object,ProcedureManager.ProcedureData> getSuperProcedures(java.lang.Object referent,
                                                                                         boolean readOnly)
```
    Get the map of the super-procedures for the given referent.
    
    Parameters:
    
    referent - The external program instance for which the super-procedures are needed.
    
    readOnly - Flag indicating that the result will not be altered.
  - cleanup
```
public void cleanup(java.lang.Object referent)
```
    Attempt cleanup of the given external program instance. If is no longer used as a persistent procedure, super procedure, or as a system handle, the referent will be removed from the pMap map.
    
    Parameters:
    
    referent - The external program instance for which needs to be cleaned up.
  - forceCleanup
```
public void forceCleanup(java.lang.Object referent)
```
    Cleanup of the given external program instance. The referent will be removed from the pMap map.
    
    Parameters:
    
    referent - The external program instance for which needs to be cleaned up.
  - getExecuting
```
private java.lang.Class<?> getExecuting()
```
    Get the Java class associated with the currently executing code.
    
    Returns:
    
    See above.
  - executingIterator
```
private java.util.Iterator<java.lang.Class<?>> executingIterator()
```
    Get an iterator over the stack of currently executing code.
    
    Returns:
    
    An iterator of Java classes associated with the code executing on the stack.
  - destinationIterator
```
private java.util.Iterator<java.lang.Object> destinationIterator()
```
    Get an iterator over the stack of destination resolved code.
    
    Returns:
    
    An iterator of Java classes associated with the code on the stack.
  - superProcForExtProc
```
private boolean superProcForExtProc(java.lang.Object referent,
                                    java.util.Collection<java.lang.Object> progs)
```
    Check if the given referent is a super-procedure of one of the procedures in the given list.
    
    Parameters:
    
    referent - The external program instance.
    
    progs - The list of external programs for which their super-procedures list will be searched for the referent.
    
    Returns:
    
    true if it was found as a super-procedure for one of the given procedures.

Class ProcedureManager.WorkArea

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

defaultDbs

tm

wp

errHelper

h

oh

persistentProcedures

sessionSuperProcs

singletonMap

pMap

targetProceduresData

sourceProceduresData

thisProceduresData

cleanupHandlers

EMPTY_SCOPE_STACK

publishSourceProcedure

internalEntryStack

pendingResources

registerPendingResources

relativeNames

processedProcedure

pendingResourceDelete

calleeInfo

initiatingExtProg

initiatingExtProgClass

deleteOnExit

remotePersistentProcedures

subscriptions

subscriptionsByEvent

persistentProcStacks

staleProcedures

Constructor Detail

WorkArea

Method Detail

init

addPersistentProcStack

hasPersistentProcStack

getPersistentProcStack

addStaleReferent

removeStaleProcedure

searchInStack

setInstantingExternalProgram

setInstantingExternalProgramClass

isRemotePersistentProcedure

getStackEntry

scopeStart

scopeFinished

scopeDeleted

getScopeId

getSessionSuperProcedures

getSuperProcedures

cleanup

forceCleanup

getExecuting

executingIterator

destinationIterator

superProcForExtProc