scopeable_6650_patch_20220901a.patch

     **     CA  20220405          Added authentication and authorization for web requests.  When this is enabled,
     **                           the target API call will be executed under the authenticated FWD context, and not
     **                           the agent's context.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
        /**
         * Register default services:
         * <ol>
         * <li> {@link SharedVariableManager} </li>
         * <li> {@link UnnamedStreams} </li>
         * <li> {@link LogicalTerminal} </li>
         * <li> {@link Persistence} </li>
         * <li> {@link AccumulatorManager} </li>
         * <li> {@link WebServer} </li>
         * <li> custom account extension plugin </li>
         * </ol>
-...
              @Override
              public void initialize()
+             {
                 SharedVariableManager.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 UnnamedStreams.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 LogicalTerminal.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 ServerKeyStore.initialize();
+             }
           });
-...
+                }
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 AccumulatorManager.initialize();
+             }
           });
           // register controller for method execution tracing
           serverHooks.add(new AbstractInitTermListener()
+          {
-...
                                        false,
                                        false);
           // make sure that the global block gets a special notification - but only for non-appserver sessions.
           if (!AppServerManager.isRemote() && !TransactionManager._isHeadless())
+          {
              Finalizable cleaner = new Finalizable()
+             {
                 @Override
                 public void finished()
+                {
                    LogicalTerminal.getInstance().pauseBeforeEnd(TransactionManager.isProcessingQuit());
+                }
                 @Override
                 public void iterate()
+                {
                    // nothing to do here
+                }
                 @Override
                 public void retry()
+                {
                    // nothing to do here
+                }
                 @Override
                 public void deleted()
+                {
                    // nothing to do here
+                }
              };
              TransactionManager.registerFinalizable(cleaner, true);
+          }
           Object result = null;
           try
+          {

     **                           were added to the collection during iterating it, resulting in a
     **                           ConcurrentModificationException (refs #6356).
     **     CA  20220707          Cache the converted Java names for the dynamic buffers.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.LogHelper;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     import com.goldencode.p2j.util.ErrorManager;
     import com.goldencode.util.*;
     import com.goldencode.util.Stack;
     /**
      * Manages all record buffers within the current user context.  This includes
-...
           @Override protected BufferManager initialValue() { return (new BufferManager()); }
        };
        /** Flag indicating whether class was initialized, i.e. {@link #initialize} was called */
        private static boolean initialized = false;
        /** A cache of buffer-related fields defined in a specific legacy-converted class. */
        private static final Map<Class<?>, Set<Field>> classBufferFields = new ConcurrentHashMap<>();
-...
        private final ScopedList<RecordBuffer> openBuffers = new ScopedList<>();
        /**
         * The buffers touched via a Create, Update or Delete operation, in each scope. If the full transaction
         * The buffers touched via a Create, Update, Copy or Delete operation, in each scope. If the full transaction
         * block is not {@link #commit committed} or {@link #rollback rolled back}, then the buffers will be merged
         * in the previous scope.
         */
-...
        private final ScopedDictionary<OutputTableHandleCopier, Integer> thOutputParameters =
           new ScopedDictionary<>();
        /** Track the external scopes pushed on {@link BufferManager}. */
        private final Stack<Boolean> externalScope = new Stack<>();
        /** Database to transaction wrapper instance map */
        private final Map<Database, TxWrapper> txWrapperMap = new HashMap<>();
-...
        /** Transaction helper */
        private final TransactionManager.TransactionHelper txHelper;
        /** Change broker instance. */
        private final ChangeBroker changeBroker;
        /** Block depth at which full application transaction began, or -1 if not in a transaction */
        private int transactionDepth = -1;
-...
           txHelper.registerStopVetoHandler(this);
           txHelper.registerResettable(this);
           changeBroker = ChangeBroker.get();
           if (LOG.isLoggable(Level.FINE))
+          {
              LOG.log(Level.FINE, "BufferManager created in context " + Utils.describeContext());
-...
+       }
        /**
         * Retrieve the context-local instance of this class, instantiating it
         * first if necessary.
         * Retrieve the context-local instance of this class, instantiating it first if necessary.
+        *
         * @return  Context-local instance of this class.
         * @throws  IllegalStateException
         *            when {@link BufferManager} is not activated, i.e. {@link
         *            #initialize()} is not called.
         */
        public static BufferManager get()
+       {
           if (!BufferManager.initialized)
+          {
              throw new IllegalStateException(
                 "An attempt to use uninitialized BufferManager. Is persistence activated?");
+          }
           BufferManager bm = context.get();
           if (bm.connMgr == null)
+          {
-...
+       }
        /**
         * Register the {@link BufferManager} instance as for scope notifications at the current block.
+        *
         * @param    bufferManager
         *           The {@link BufferManager} instance.
         */
        public static void registerScopeable(BufferManager bufferManager)
+       {
           if (bufferManager == null)
+          {
              bufferManager = get();
+          }
           bufferManager.txHelper.registerBlockScopeable(bufferManager);
           bufferManager.txHelper.registerBlockScopeable(bufferManager.changeBroker);
+       }
        /**
         * Register the {@link BufferManager} instance as pending scopeable, to be added to the next block.
+        *
         * @param    bufferManager
         *           The {@link BufferManager} instance.
         */
        public static void registerPendingScopeable(BufferManager bufferManager)
+       {
           if (bufferManager == null)
+          {
              bufferManager = get();
+          }
           bufferManager.txHelper.registerPendingScopeable(bufferManager);
           bufferManager.txHelper.registerPendingScopeable(bufferManager.changeBroker);
+       }
        /**
         * Cleanup of pending resources. This is called when the external procedure constructor failed
         * to build a new object because of an exception thrown in a member initialization (shared
         * frame/table).
-...
+       }
        /**
         * Register with the {@link com.goldencode.p2j.util.TransactionManager
         * TransactionManager} a factory object which creates instances of this
         * class, so that they can be registered to receive notifications of
         * runtime scope start and finish events.
         * <p>
         * This method should be invoked once during the server bootstrap phase.
         */
        static void initialize()
+       {
           TransactionManager.registerScopeableFactory(BufferManager::get);
           BufferManager.initialized = true;
+       }
        /**
         * Register this buffer as 'dirty' in the current scope.
         * <p>
         * This registration doesn't mean that at the time of {@link #commit}, {@link #rollback}, or
-...
+       }
        /**
         * Find the nearest external block (from the bottom of the stack).
+        *
         * @return   See above.
         */
        public int findNearestExternal()
+       {
           int idx = externalScope.size() - 1;
           while (idx > 0)
+          {
              if (externalScope.get(idx))
+             {
                 return idx + 1;
+             }
              idx = idx - 1;
+          }
           return -1;
+       }
        /**
         * Check the specified exception and determine whether we want to allow it
         * to be honored by the {@link TransactionManager}, or whether we want to
         * veto the STOP at this scope.
-...
           thOutputParameters.addScope(null);
           undoData.addScope(null);
           fieldScopes.scopeStart();
           externalScope.push(txHelper.isExternalBlock());
           BatchModeData crtBatchScope = batchModeStack.peek();
           if (crtBatchScope != null && crtBatchScope.batchDepth == BatchModeData.INTERNAL)
-...
           fieldScopes.scopeFinished();
           openStaticTempTables.deleteScope();
           thOutputParameters.deleteScope();
           externalScope.pop();
           BatchModeData bmd = batchModeStack.pop();
           if (bmd.batchDepth == BatchModeData.INTERNAL)
+          {
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#BUFFER_MANAGER}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.BUFFER_MANAGER;
+       }
        /**
         * Provides a notification that a batch is starting or ending.  Enters or
         * exits batch assignment mode for all record buffers in this context,
         * depending on the value of <code>start</code>.
-...
+        *
         * @return  {@code true} if we are in a transaction, else {@code false}.
         */
        @Deprecated
        public boolean isTransactionAt(int level)
+       {
           return transactionDepth >= 0 && transactionDepth <= level;
-...
         * @return  {@code true} if we are at (and within) a full transaction boundary, else {@code
         *          false}.
         */
        @Deprecated
        public boolean isFullTransaction()
+       {
           // TODO: this has dependency on the full app stack
           return transactionDepth >= 0 && getOpenBufferScopes() - 1 == transactionDepth;
+       }
-...
         * @return  Zero-based block depth of current, full transaction, or -1 if we are not currently
         *          within a transaction.
         */
        @Deprecated
        public int getFullTransactionBlock()
+       {
           return transactionDepth;
-...
         */
        void openScopeAt(int openScopeDepth, RecordBuffer buffer)
+       {
           // TODO: this seems to be called only for 'openScopeDepth == 0'.
           if (buffer.isActive())
+          {
              if (openScopeDepth == 0)
-...
         * @return  {@code true} if the block is considered &quot;important&quot; by the above criteria, else
         *          {@code false}.
         */
        private boolean isImportantBlockTransition()
        public boolean isImportantBlockTransition()
+       {
           return !txHelper.isTransaction() ||
                  txHelper.currentTransactionLevel() != TransactionManager.NO_TRANSACTION;
-...
         * primary key.  One instance of this class holds all such objects for a
         * single buffer in a single scope.
         */
        @Deprecated
        private static class UndoData
+       {
           /** Undoable which will set a no-undo buffer to its proper record after a rollback. */

     **                           Use an identity HashSet where possible.
     **     CA  20220309          Added isQueried(), which checks if a temp-table has any listeners registered for
     **                           events which are a P2JQuery.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
     import com.goldencode.p2j.persist.orm.*;
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     /**
      * A clearing house which notifies interested parties of changes made to
-...
+       }
        /**
         * Register with the {@link com.goldencode.p2j.util.TransactionManager
         * TransactionManager} a factory object which creates instances of this
         * class, so that they can be registered to receive notifications of
         * runtime scope start and finish events.
         * <p>
         * This method should be invoked once during the server bootstrap phase.
         */
        static void initialize()
+       {
           TransactionManager.registerScopeableFactory(ChangeBroker::get);
+       }
        /**
         * Add a scope to the listeners dictionary whenever a new runtime scope
         * opens.
         */
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#CHANGE_BROKER}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.CHANGE_BROKER;
+       }
        /**
         * Register a listener to receive DMO property change notifications.  The
         * listener will receive notifications of any changes to DMOs of the types
         * for which it is registered, as they occur in this scope or in scopes

     **                           its own block and not via a QUERY resource).
     **     IAS 20220510          Resetting activeIndex before iterating over the components for current(LockType)
     **     IAS 20220707          Resetting nullOuter on new iteration step.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
           activeIndex = -1;
           preselected = false;
           int lowestScope = registerRecordChangeListeners();
           boolean globalScope = registerRecordChangeListeners();
           super.open();
-...
              preselectResults();
+          }
           initReferenceRowSupport(lowestScope);
           initReferenceRowSupport(globalScope);
+       }
        /**
-...
         * Init structures required to use reference row: create the map of all buffers, register
         * parameter filters for sub-queries and register this query as a record change listener.
+        *
         * @param   blockDepth
         *          Depth of the block at which this query is registered as record change listener.
         *          <code>0</code> for global scope.
         * @param   globalScope
         *          Flag indicating if the block at which this query is registered as record change listener is
         *          the global scope.
         */
        protected void initReferenceRowSupport(int blockDepth)
        protected void initReferenceRowSupport(boolean globalScope)
+       {
           if (!preselect && buffersMap == null)
+          {
-...
+             }
              ChangeBroker.get().addListener(this);
              if (blockDepth == 0)
              if (globalScope)
+             {
                 unregisterOnCleanup = true;
+             }
-...
        @SuppressWarnings("unchecked")
        protected Object[] retrieve(int navigation, LockType lockType, boolean iterating, boolean peek)
+       {
           initReferenceRowSupport(-1);
           initReferenceRowSupport(false);
           Object[] rowData;
-...
        /**
         * Register the query within each component as a record change listener.
+        *
         * @return  The lowest scope found among all the components' record buffers.
         * @return  <code>true</code> if the global scope is used for registration.
         */
        private int registerRecordChangeListeners()
        private boolean registerRecordChangeListeners()
+       {
           // Find for each compound query component the most outer scope among
           // nearest external scope and the outermost scopes of buffers used by
           // this component and register the component into this scope.
           int externalScope = TransactionManager.findNearestExternal();
           int externalScope = BufferManager.get().findNearestExternal();
           int lowestScope = externalScope;
           for (CompoundComponent comp : getComponents())
-...
+             }
+          }
           return lowestScope;
           return lowestScope == 0;
+       }
        /**

     **     CA  20220106 Fixed CREATE-LIKE when relations are involved, their active flag was not being copied
     **                  properly.
     **     OM  20220422 Allow Xml/JsonImport to load records into buffer without exposing package private methods.
     **     CA  20220901 Refactored scope notification support: ScopeableFactory was removed, and the registration
     **                  is now specific to each type of scopeable.  For each case, the block will be registered
     **                  for scope support (for that particular scopeable) only when the scopeable is 'active'
     **                  (i.e. unnamed streams or accumulators are used).  This allows a lazy registration of
     **                  scopeables, to avoid the unnecessary overhead of processing all the scopeables for each
     **                  and every block.
     */
     /*
-...
              throw new IllegalStateException("Parameter mode (INPUT/OUTPUT) was not specified!");
+          }
           DataSetManager.registerScopeable();
           StaticDataSet localDS = (StaticDataSet) dsTarget;
           if (!dsSrc.isRemoteParameter())
+          {
-...
              throw new IllegalStateException("Parameter mode (INPUT/OUTPUT) was not specified!");
+          }
           DataSetManager.registerScopeable();
           if (output)
+          {
              TransactionManager.registerCurrent(dsHandle);

     ** Module   : DataSetManager.java
     ** Abstract : Manages all the DataSets, taking care for matching shared ones.
     **
     ** Copyright (c) 2019-2020, Golden Code Development Corporation.
     ** Copyright (c) 2019-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description---------------------------------
     ** 001 OM  20190403 Created initial version.
-...
     **     OM  20190731 Added REFERENCE-ONLY support.
     ** 004 CA  20200110 More fixes for DATASET parameters and resource delete.
     ** 005 CA  20201003 Allow dictionaries with an identity map.
     **     CA  20220901 Refactored scope notification support: ScopeableFactory was removed, and the registration
     **                  is now specific to each type of scopeable.  For each case, the block will be registered
     **                  for scope support (for that particular scopeable) only when the scopeable is 'active'
     **                  (i.e. unnamed streams or accumulators are used).  This allows a lazy registration of
     **                  scopeables, to avoid the unnecessary overhead of processing all the scopeables for each
     **                  and every block.
     */
     /*
-...
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     import java.util.*;
-...
        /** A dictionary of BY-REFERENCE dataset parameters. */
        private final ScopedDictionary<DataSet, Integer> byReferenceParameters = new ScopedDictionary<>();
        /** The transaction helper. */
        private final TransactionManager.TransactionHelper tm;
        /**
         * Default c'tor.  Marks dictionaries which can use identity maps.
         */
        private DataSetManager()
+       {
           tm = TransactionManager.getTransactionHelper();
           dshOutputParams.setIdentityKeys(true);
           byReferenceParameters.setIdentityKeys(true);
           // there is a bug with static datasets: instead of registering as 'pending' for next scope, they are
           // registering in the callee's scope... so, for now, push an 'implicit' scope here.
           scopeStart();
+       }
        /**
-...
           return instance.get();
+       }
        /**
         * Register with the {@link com.goldencode.p2j.util.TransactionManager
         * TransactionManager} a factory object which creates instances of this
         * class, so that they can be registered to receive notifications of
         * runtime scope start and finish events.
         * <p>
         * This method should be invoked once during the server bootstrap phase.
         * Register the {@link DataSetManager} for scope notifications at the current block.
         */
        static void initialize()
        public static void registerScopeable()
+       {
           TransactionManager.registerScopeableFactory(DataSetManager::instance);
           DataSetManager mgr = instance();
           mgr.tm.registerBlockScopeable(mgr);
+       }
        /**
-...
         */
        public void register(DataSet dataSet, String legacyName, boolean isShared, boolean isNew)
+       {
           tm.registerPendingScopeable(this);
           if (!dataSet._dynamic())
+          {
              registry.addEntry(false, legacyName.toLowerCase(), dataSet);
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#DATA_SET_MANAGER}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.DATA_SET_MANAGER;
+       }
        /**
         * Check if the given dataset is passed as a BY-REFERENCE parameter.
+        *
         * @param    ds

     **     IAS 20220608          Provide additional information in reportUDFVersion().
     **     IAS 20220712          Create missing UDFs
     **     IAS 20220816          Do not use 'udf' schema for non-PostgreSQL UDFs
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
         * Initialize various infrastructure components of the persistence framework:
         * <ul>
         *   <li>{@code DataTypeHelper}, which is used when preprocessing FQL where clauses.
         *   <li>{@code BufferManager}, which tracks open buffers and transactions.
         *   <li>{@code ChangeBroker}, which dispatches notifications about changes to DMO properties.
         *   <li>{@code DatabaseManager}, which configures the ORM environment for the databases
         *       to which the framework connects.
         *   <li>{@code P2OLookup}, instances of which are used for runtime, on-the-fly query and
-...
         *          if any error is encountered initializing the persistence framework.
+        *
         * @see     DataTypeHelper#initialize()
         * @see     BufferManager#initialize()
         * @see     ChangeBroker#initialize()
         * @see     DatabaseManager#initialize()
         * @see     TemporaryDatabaseManager#initialize()
         * @see     DataSetManager#initialize()
         * @see     P2OLookup#initialize()
         */
        public static void initialize()
        throws PersistenceException
+       {
           DataTypeHelper.initialize();
           BufferManager.initialize();
           ChangeBroker.initialize();
           TemporaryDatabaseManager.initialize();
           DatabaseManager.initialize();
           DataSetManager.initialize();
           // if runtime conversion services are required, initialize schema lookup resources
           if (ConversionPool.isInitialized())

     **                           must be used, as the buffer instance may be proxied.  Fixed OM/20220707.
     **     OM  20220809          Use a temporary virtual scope while invoking the db triggers to block the
     **                           release() to be recursively invoked at the end of a trigger().
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
+                   }
                    // heuristically convert from SQL name to legacy name
                    Iterator<Property> fields = buffer.dmoInfo.getFields(false);
                    Iterator<Property> fields = buffer.getDmoInfo().getFields(false);
                    while (fields.hasNext())
+                   {
                       Property prop = fields.next();
-...
           BufferReference srcProxy = (BufferReference) srcDmo;
           RecordBuffer srcBuf = srcProxy.buffer();
           RecordBuffer dstBuf = dstProxy.buffer();
           dstBuf.bufferManager.registerDirtyBuffer(dstBuf);
           srcBuf.initialize();
           dstBuf.initialize();
-...
              return new logical(false);
+          }
           dstBuf.bufferManager.registerDirtyBuffer(dstBuf);
           boolean created = false;
           Record dstRec = dstBuf.getCurrentRecord();
           if (dstRec == null)
-...
         */
        protected void openScopeAt(int blockDepth)
+       {
           // TODO: blockDepth param is always zero...
           // Register this scope with the buffer manager.
           bufferManager.openScopeAt(blockDepth, this);

     **     TW  20220803          Error-status:error must be set for return error in method, while return error
     **                           in old-style ABL function must remain the same. Refs: #6567.
     **     TW  20220817          Error-status:error must be set for return error in static method.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.LogHelper;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     import java.lang.reflect.*;
     import java.util.*;
     import java.util.logging.Level;
-...
         */
        private DatabaseTriggerManager()
+       {
           // I want to receive enter/leave bloc events
           tm.registerScopeable(this);
           if (LOG.isLoggable(Level.FINE))
+          {
              LOG.log(Level.FINE, "DatabaseTriggerManager registered with TransactionManager.");
-...
                                                   boolean hasOldBuffer)
+       {
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              // sanity check failed
-...
              throw new IllegalArgumentException("Use this form of register only for ASSIGN triggers.");
+          }
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              // sanity check failed
-...
+          }
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              // sanity check failed
-...
+          }
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              // sanity check failed
-...
        public static boolean disableDumpTriggers(Class<? extends Buffer> bufferCls)
+       {
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              return false;
-...
                                                  boolean allowReplication)
+       {
           DatabaseTriggerManager manager = get();
           manager.tm.registerTopLevelScopeable(manager);
           if (manager.stack.isEmpty())
+          {
              return false;
-...
        public void scopeStart()
+       {
           // triggers get notifications at all top level blocks
           if (tm.isTopLevelBlock())
+          {
              stack.addFirst(new TriggerBlockLayer()); // push();
+          }
           stack.addFirst(new TriggerBlockLayer()); // push();
+       }
        /**
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#DATABASE_TRIGGER_MANAGER}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.DATABASE_TRIGGER_MANAGER;
+       }
        /**
         * Provides a notification that a scope is about to be exited. The manager only acts on
         * top-level scope. Each time a scope is exited a the last layer of triggers is removed from
         * internal stack.
-...
        public void scopeFinished()
+       {
           // triggers get notifications at all top level blocks
           if (tm.isTopLevelBlock())
+          {
              if (stack.isEmpty())
+             {
                 LOG.log(Level.WARNING, "Invalid scope finished.");
+             }
              else
+             {
                 stack.removeFirst(); // pop();
+             }
           if (stack.isEmpty())
+          {
              LOG.log(Level.WARNING, "Invalid scope finished.");
+          }
           else
+          {
              stack.removeFirst(); // pop();
+          }
+       }

     **                           widget is explicitly specified.
     **     EVL 20220809          Fixed the regression from recent HIDDEN attribute reset change.  Only widgets
     **                           defined in DISPLAY statement should be affected.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
        public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable
+       {
           // frame is accessed, register scopeable
           TransactionManager.registerBlockScopeable(LogicalTerminal.getInstance());
           int    op         = -1;
           String widgetName = null;
-...
           // push down the screen definition
           if (force)
+          {
              TransactionManager.registerBlockScopeable(LogicalTerminal.getInstance());
              // synchronous push
              ScreenDefinition[] sd = new ScreenDefinition[] {frameDef};
              LogicalTerminal.pushScreenDefinition(sd);

     **     TW  20220803          Error-status:error must be set for return error in method, while return error
     **                           in old-style ABL function must remain the same. Refs: #6567.
     **     TW  20220817          Error-status:error must be set for return error in static method.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.ErrorManager;
     import com.goldencode.p2j.util.ErrorManager.*;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     import com.goldencode.p2j.util.LogHelper;
     import com.goldencode.p2j.util.SocketImpl;
     import com.goldencode.p2j.util.Text;
-...
+          }
           LogicalTerminal lt = locate();
           lt.scopeTrack.forceHiding();
           lt.forceHiding();
           lt.client.hideAll(noPause, targetWindowWorker(hWin, false));
           // TODO get frames from target window?
-...
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           frame.setHadView();
           // refresh editable frames list
-...
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           frame.setHadView();
           // refresh editable frames list
-...
           ScreenBuffer[] frameBuf = (frame == null) ? null : lt.getEditableServerScreenBuffers(frame);
           int          windowId = (frame == null) ? WindowConfig.RESOLVE_WINDOW : frame.getWindowId();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           FieldGroup fg;
           if (frame != null)
+          {
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           view(frame.getFrameId(),
                lt.getEditableServerScreenBuffers(frame),
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           view(frame.getFrameId(),
                lt.getEditableServerScreenBuffers(frame),
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           WidgetConfig[] wcfgs = lt.client.view(frame.getFrameId(),
                                                 lt.getEditableServerScreenBuffers(frame),
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           FieldGroup fg = frame.getFieldGroup();
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           WidgetConfig[] wcfgs = lt.client.view(frame.getFrameId(),
                                                 lt.getEditableServerScreenBuffers(frame),
-...
+       {
           LogicalTerminal lt = locate();
           lt.scopeTrack.frameViewed(frame);
           lt.frameViewed(frame);
           view(frame.getFrameId(),
                frameBuf,
-...
           // call the client
           try
+          {
              lt.scopeTrack.frameViewed(frame);
              lt.frameViewed(frame);
              int[] tabItemList = frame.updateTabItemsList(widgetIds, UpdatesOp.PROMPT_FOR);
-...
           // we haven't had the chance to mark the next partition yet because
           // scopeStart() won't be called until the business logic initializer
           // is complete
           locate().level2definitions.add(frameDef);
           LogicalTerminal lt = locate();
           lt.level2definitions.add(frameDef);
           lt.tm.registerPendingScopeable(lt);
+       }
        /**
-...
           // we haven't had the chance to mark the next partition yet because
           // scopeStart() won't be called until the business logic initializer
           // is complete
           locate().level2descriptions.add(menuDescr);
           LogicalTerminal lt = locate();
           lt.level2descriptions.add(menuDescr);
           lt.tm.registerPendingScopeable(lt);
+       }
        /**
-...
        public static void processDeferredPush(boolean fromLevel2)
+       {
           LogicalTerminal lt = locate();
           lt.tm.registerBlockScopeable(lt);
           if (fromLevel2)
+          {
              lt.definitions.markPartition();
-...
         */
        static void deregisterFrame(int frameId)
+       {
           locate().deregisterFrameInt(frameId);
           LogicalTerminal lt = locate();
           lt.tm.registerBlockScopeable(lt);
           lt.deregisterFrameInt(frameId);
+       }
        /**
-...
              return frameRegistry.get(frameId);
+          }
+       }
        /**
         * Notify scope that frame is viewed.
         * <p>
         * This also registeres {@link LogicalTerminal} for scope notifications at the current block.
+        *
         * @param   frame
         *          Frame which is about to be viewed.
         */
        private void frameViewed(GenericFrame frame)
+       {
           tm.registerBlockScopeable(this);
           scopeTrack.frameViewed(frame);
+       }
        /**
         * Clear map of viewed frames.
         * <p>
         * This also registeres {@link LogicalTerminal} for scope notifications at the current block.
         */
        private void forceHiding()
+       {
           tm.registerBlockScopeable(this);
           scopeTrack.forceHiding();
+       }
        /**
         * Save the {@link UIStatement} running for each registered frame.
+        *
         * @return   A map with each frame's UI statement.
-...
+       }
        /**
         * Register with the {@link com.goldencode.p2j.util.TransactionManager TransactionManager} a
         * factory object which creates instances of this class, so that they can be registered to
         * receive notifications of runtime scope start and finish events.
         * <p>
         * This method should be invoked once during the server bootstrap phase.
         * <p>
         * The registered factory functions conditionally. It uses the {@link
         * TransactionManager#_isHeadless()} to check whether the context has been declared headless.
         */
        public static void initialize()
+       {
           TransactionManager.registerScopeableFactory(
              () -> TransactionManager._isHeadless() ? null : LogicalTerminal.locate()
           );
+       }
        /**
         * Process a notification that a new block scope is about to be entered.
         * <p>
         * In the Logical Terminal, a new top level block scope causes creation of
-...
        @Override
        public void scopeStart()
+       {
           // scopeable registration is done in different places - if changes are made, ensure that scopeable
           // support is registered properly.
           // register at each scope, it is important to instantiate the scope
           // processor BEFORE the state.interactions counter is reset below
           tm.registerFinalizable(new ScopeProcessor(), false);
-...
              state.interactions = 0;
+          }
           // make sure that the global block gets a special notification - but only for non-appserver sessions.
           if (tm.isGlobalBlock() && !tm.isRemote())
+          {
              Finalizable cleaner = new Finalizable()
+             {
                 @Override
                 public void finished()
+                {
                    pauseBeforeEnd(tm.isProcessingQuit());
+                }
                 @Override
                 public void iterate()
+                {
                    // nothing to do here
+                }
                 @Override
                 public void retry()
+                {
                    // nothing to do here
+                }
                 @Override
                 public void deleted()
+                {
                    // nothing to do here
+                }
              };
              tm.registerFinalizable(cleaner, true);
+          }
           // add a new scope for each top-level block
           if (tm.isTopLevelBlock())
+          {
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#LOGICAL_TERMINAL}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.LOGICAL_TERMINAL;
+       }
        /**
         * Called by the protocol driver to obtain the latest state that should
         * be sent to the other side of the connection.  This is called just
         * before a "real" message is sent and any changes provided will be
-...
              if (cs.deregister != null)
+             {
                 tm.registerBlockScopeable(this);
                 for (int i : cs.deregister)
+                {
                    deregisterFrameInt(i);
-...
              if (cs.wrapped != null && scopeTrack != null)
+             {
                 tm.registerBlockScopeable(this);
                 for (int id : cs.wrapped)
+                {
                    scopeTrack.frameWrapped(id);

     ** Module   : MenuContainerWidget.java
     ** Abstract : The base class for MenuWidget and SubMenuWidget.
     **
     ** Copyright (c) 2015-2020, Golden Code Development Corporation.
     ** Copyright (c) 2015-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description----------------------------------
     ** 001 VIG 20150115 Created initial version.
-...
     **     EVL 20201021 More optimization for getAttr() usage or widget ID getting.
     **     EVL 20201022 Optimized attributes flush implementation.
     **     CA  20201117 Do not use resourceDelete to delete the widget - use the delete() API for this code.
     **     CA  20220901 Refactored scope notification support: ScopeableFactory was removed, and the registration
     **                  is now specific to each type of scopeable.  For each case, the block will be registered
     **                  for scope support (for that particular scopeable) only when the scopeable is 'active'
     **                  (i.e. unnamed streams or accumulators are used).  This allows a lazy registration of
     **                  scopeables, to avoid the unnecessary overhead of processing all the scopeables for each
     **                  and every block.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
           // push down the screen definition
           if (force)
+          {
              TransactionManager.registerBlockScopeable(LogicalTerminal.getInstance());
              // synchronous push
              MenuDescription[] sd = new MenuDescription[] {root.menuDef};
              LogicalTerminal.pushMenuDescription(sd);

     **                           the resource gets deleted (including widgets).
     **     CA  20210917          Javadoc fixes.
     **     SBI 20220126          Fixed scopeFinished to add preserved events before all events from the target list.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
                                    EventList             events,
                                    int                   tid)
+       {
           TransactionManager.registerBlockScopeable(LogicalTerminal.getInstance());
           events.setTriggerId(tid);
           // insert the latest trigger def at the front of the list. all created triggers are saved,
-...
        @SuppressWarnings("unchecked")
        public static void deregister(ScopedDictionary<?,?> registry, EventList el)
+       {
           TransactionManager.registerBlockScopeable(LogicalTerminal.getInstance());
           LinkedList<EventList> registryScope = null;
           // DEBUG: System.err.printf("DEREGISTER\nBEFORE %s", dumpRegistry(registry));

     ** Abstract : Common logic for assigns [input-]output parameter values (database fields and normal
     **            variables) upon exit from procedure/function
     **
     ** Copyright (c) 2015-2021, Golden Code Development Corporation.
     ** Copyright (c) 2015-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------------Description----------------------------------------
     ** 001 OM  20150702 First version based on extracted code form AbstractSimpleParameter and
-...
     **                  in the parameter instance must be replaced.
     **     CA  20210609 Reworked INPUT/INPUT-OUTPUT parameters to a new approach, where they are explicitly
     **                  initialized at the method's execution, and not at the caller's arguments.
     **     CA  20220901 Refactored scope notification support: ScopeableFactory was removed, and the registration
     **                  is now specific to each type of scopeable.  For each case, the block will be registered
     **                  for scope support (for that particular scopeable) only when the scopeable is 'active'
     **                  (i.e. unnamed streams or accumulators are used).  This allows a lazy registration of
     **                  scopeables, to avoid the unnecessary overhead of processing all the scopeables for each
     **                  and every block.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     import java.lang.reflect.*;
     import java.util.*;
     import java.util.logging.*;
-...
+          }
           /**
            * Get the {@link ScopeId} for the instance.
+           *
            * @return   <code>null</code>, as the notification is done via {@link BufferManager}.
            */
           @Override
           public ScopeId getScopeId()
+          {
              // no explicit registration is done, this is called via BufferManager
              return null;
+          }
           /**
            * Get the object which manages field assigners for the current scope.
+           *
            * @return  Current scope.

     ** Module   : Accumulator.java
     ** Abstract : Abstract base class for concrete accumulator implementations
     **
     ** Copyright (c) 2004-2019, Golden Code Development Corporation.
     ** Copyright (c) 2004-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- --JPRM-- -----------------------------Description-----------------------------
     ** 001 ECF 20051227   @23778 Created initial version. Base class for
-...
     **                           when reset() called without accumulate().
     ** 028 CA  20190326          Implemented TransactionHelper instead of direct usage of the static
     **                           API.  This allows the elimination of context local usage in TM.
     ** 029 CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
     import java.lang.reflect.*;
     import java.util.*;
     import com.goldencode.p2j.util.Scopeable.ScopeId;
     /**
      * Abstract base class for all accumulators.  An accumulator collects one
      * piece of data upon each pass through an iterative loop and calculates a
-...
+       {
           // no-op
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   <code>null</code>, as the scope notification is done via {@link AccumulatorManager}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           // no ID necessary, as it does not get registered explicitly, is called via AccumulatorManager
           return null;
+       }
        /**
         * Process a notification that a new block scope has been entered. Each

     ** Module   : AccumulatorManager.java
     ** Abstract : provides block-behavior for the accumulators.
     **
     ** Copyright (c) 2008-2021, Golden Code Development Corporation.
     ** Copyright (c) 2008-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- -T- --JPRM-- ----------------Description-----------------
     ** 001 CA  20080129   @37024 Created initial version. Provides context
-...
     ** 010 CA  20200930          Refactored to remove the singleton scopeable instance (which forced the scope
     **                           notifications to use context-local state).
     **     CA  20210310          Small performance improvement.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
     import java.util.*;
     import com.goldencode.p2j.security.ContextLocal;
     import com.goldencode.p2j.util.Scopeable.ScopeId;

Project

General

Profile

FWD » Core Development » Base Language