stateless_lambda.patch

         * @param r
         *        operation to be executed
         */
        public void timer(Operation r)
        public void timer(Operation r, Object... args)
+       {
            if (!enabled)
+           {
                try
+               {
                   r.exec();
                   r.exec(args);
+               }
                catch (RuntimeException re)
+               {
-...
            start();
            try
+           {
               r.exec();
               r.exec(args);
+           }
            catch (RuntimeException re)
+           {
               // unchecked exception propagate as is.  otherwise, we can't process ConditionException.
               throw re;
+           }
            catch (Exception e)
+           {
               throw new RuntimeException(e);
+           }
            finally
+           {
                stop();
+           }
+       }
        /**
         * Execute operation and measure execution time
         * @param r
         *        operation to be executed
         */
        public Object timer(ReturningOperation r, Object... args)
+       {
            if (!enabled)
+           {
                try
+               {
                   return r.exec(args);
+               }
                catch (RuntimeException re)
+               {
                   // unchecked exception propagate as is.  otherwise, we can't process ConditionException.
                   throw re;
+               }
                catch (Exception e)
+               {
                   throw new RuntimeException(e);
+               }
+           }
            start();
            try
+           {
               return r.exec(args);
+           }
            catch (RuntimeException re)
+           {

new/src/com/goldencode/p2j/jmx/Operation.java 2023-02-15 15:52:10 +0000
73	73	* Execute operation
74	74	* @throws Exception
75	75	*/
76		public void exec()
	76	public void exec(Object... args)
77	77	throws Exception;
78	78	}

     package com.goldencode.p2j.jmx;
     /** Functional interface for operations which may throw exceptions */
     @FunctionalInterface
     public interface ReturningOperation
+    {
        /**
         * Execute operation
         * @throws Exception
         */
        public Object exec(Object... args)
        throws Exception;
+    }

           key.readExternal(in);
     //      System.err.printf("Deserializing payload for %d; ", requestID);
           NANO_TIMER.timer(
                 () -> setPayload(PayloadSerializer.readPayload(in))
           );
           NANO_TIMER.timer((Operation) (args) -> setPayload(PayloadSerializer.readPayload((ObjectInput) args[0])), in);
     //      onRead();
+       }
-...
           out.writeInt(requestID);
           key.writeExternal(out);
     //      onWrite();
           NANO_TIMER.timer(
                 () -> PayloadSerializer.writePayload(out, payload)
           );
           NANO_TIMER.timer((Operation) (args) ->
              PayloadSerializer.writePayload((ObjectOutput) args[0], args[1]), out, payload);
+       }
        /*

                    // Java approach handles reading an entire array as a single
                    // entity which is something we want to avoid doing ourselves
                    TO_BYTE_ARRAY_TIMER.timer(
                         () -> setData(objToByteArray(obj))
                    );
                    TO_BYTE_ARRAY_TIMER.timer((Operation) (args) -> setData(objToByteArray((Message) args[0])), obj);
                    if (data != null)
+                   {
                       OUTGOING.update(data.length);

new/src/com/goldencode/p2j/persist/BufferImpl.java 2023-02-15 16:11:28 +0000
9836	9836	@Override
9837	9837	protected boolean resourceDelete()
9838	9838	{
9839		boolean[] res = new boolean[1];
9840
9841		RESOURCE_DEL.timer(() -> res[0] = resourceDeleteImpl());
9842
9843		return res[0];
	9839	return (boolean) RESOURCE_DEL.timer((ReturningOperation) (args) -> resourceDeleteImpl());
9844	9840	}
9845	9841
9846	9842	/**

         */
        public static void associate(DataSetParameter dsSrc, DataSet dsTarget, EnumSet<ParameterOption> options)
+       {
           STATIC_PARAM.timer(() -> associateImpl(dsSrc, dsTarget, options));
           STATIC_PARAM.timer((Operation) (args) -> associateImpl(
                    (DataSetParameter) args[0],
                    (DataSet) args[1],
                    (EnumSet<ParameterOption>) args[2]),
                 dsSrc, dsTarget, options);
+       }
        /**
-...
                                                handle           dsHandle,
                                                ParameterOption  option)
+       {
           DYN_PARAM.timer(() -> createDynamicDataSetImpl(dsParam, dsHandle, option));
           DYN_PARAM.timer((Operation) (args) -> createDynamicDataSetImpl(
                    (DataSetParameter) args[0],
                    (handle) args[1],
                    (ParameterOption) args[2]),
                 dsParam, dsHandle, option);
+       }
        /**

     import java.io.*;
     import java.util.*;
     import java.util.List;
     import java.util.Map;
     import java.util.concurrent.atomic.*;
     import java.util.logging.*;
     import antlr.*;
-...
+        *
         * @return  A {@link P2JQuery} instance representing the given legacy query string.
         */
        @SuppressWarnings("unchecked")
        private static P2JQuery parse(QueryProcessor processor,
                                      List<Buffer> buffers,
                                      String predicate0,
-...
                 final SymbolResolver[] sym = new SymbolResolver[1]; // build the symbol resolver
                 final SchemaDictionary[] dict = new SchemaDictionary[1];
                 PROCESS_SYMRES.timer(() -> {
                 // TODO: refactor to stop using stateful lambda
                 PROCESS_SYMRES.timer((args) -> {
                    sym[0] = SymbolResolver.newRuntimeInstance();
                    dict[0] = RecordBuffer.getSchemaDictionary(allBuffers);
                    sym[0].setSchemaDictionary(dict[0]); // set the schema dictionary used by this context
                 });
                    dict[0] = RecordBuffer.getSchemaDictionary((List<Buffer>) args[0]);
                    sym[0].setSchemaDictionary((SchemaDictionary) args[1]); // set the schema dictionary used by this context
                 }, allBuffers, dict[0]);
                 try
+                {
-...
                    try
+                   {
                       // load the p2o and schema data
                       PROCESS_SCHEMADICT.timer(() -> prepareTempTable(dict[0], pCode, wa.p2oFile, wa.buffers));
                       PROCESS_SCHEMADICT.timer((Operation) (args) -> prepareTempTable((SchemaDictionary) args[0],
                                                                                       (StringBuilder) args[1],
                                                                                       (String) args[2],
                                                                                       (ArrayList<Buffer>) args[3]),
                                                dict[0], pCode, wa.p2oFile, wa.buffers);
+                   }
                    catch (RuntimeException exc2)
+                   {
-...
+                   }
                    // add a default scope that represents the scope of the external procedure
                    PROCESS_SYMRES.timer(() -> sym[0].addSchemaScope(false));
                    PROCESS_SYMRES.timer((Operation) (args) -> ((SymbolResolver) args[0]).addSchemaScope(false), sym[0]);
                    // parse the predicate
                    String predicate = processor.preparePredicate(predicate0);
-...
                    Exception err = null;
                    String oeCode = pCode.toString();
                    StringReader in = new StringReader(oeCode);
                    PROCESS_PARSE.timer(() -> {
                    PROCESS_PARSE.timer((args) -> {
                       lexer[0] = new ProgressLexer(in, sym[0]);
                       lexer[0].setUnixEscapes(!EnvironmentOps.isUnderWindowsFamily());
                       parser[0] = new ProgressParser(lexer[0], sym[0]);
-...
                       //         OPEN QUERY DynGenQuery <query-predicate>.
     //                  PROCESS_PARSE2.timer(() -> parser[0].external_proc());
                       PROCESS_PARSE2.timer(() -> parser[0].dynamic_query_proc());
                       PROCESS_PARSE2.timer((Operation) (args) -> ((ProgressParser) args[0]).dynamic_query_proc(), parser[0]);
                       complete = true;
+                   }
                    catch (RuntimeException exc2)
-...
+                   {
                       // prepare the initial AST
                       ProgressAst finalPAst0 = (ProgressAst) parser[0].getAST();
                       PROCESS_SETUP.timer(() -> {
                       PROCESS_SETUP.timer((args) -> {
                          finalPAst0.brainwash(wa.dynQueryFile, true);
                          prepareTree(finalPAst0, wa.buffers, wa.dynQueryFile, DYN_GEN_QUERY_CLASS);
-...
                       if (qAst == null)
+                      {
                          // run conversion
                          PROCESS_ANNOTATION.timer(() -> ConversionPool.runTask(ConversionProfile.ANNOTATIONS, finalPAst0));
                          PROCESS_ANNOTATION.timer((Operation) (args) ->
                             ConversionPool.runTask(ConversionProfile.ANNOTATIONS, (Aast) args[0]), finalPAst0);
                          ProgressAst finalPAst1 = (ProgressAst) astManager.loadTree(wa.astFile);
                          PROCESS_BASE.timer(() -> ConversionPool.runTask(ConversionProfile.BASE_STRUCTURE, finalPAst1));
                          PROCESS_BASE.timer((Operation) (args) ->
                             ConversionPool.runTask(ConversionProfile.BASE_STRUCTURE, (Aast) args[0]), finalPAst1);
                          ProgressAst finalPAst2 = (ProgressAst) astManager.loadTree(wa.astFile);
                          PROCESS_CORE.timer(() -> ConversionPool.runTask(ConversionProfile.CORE_CONVERSION, finalPAst2));
                          PROCESS_CORE.timer((Operation) (args) ->
                             ConversionPool.runTask(ConversionProfile.CORE_CONVERSION, (Aast) args[0]), finalPAst2);
                          ProgressAst pAst = (ProgressAst) astManager.loadTree(wa.astFile);
-...
                          JavaAst jCode = (JavaAst) astManager.loadTree(wa.jastFile);
                          // DBG: System.out.println(jCode.dumpTree(true));
                          // DBG: System.out.println(ConversionPool.runTask(ConversionProfile.BREW, jCode).getStoredObject(DYN_GEN_QUERY_CLASS));
                          PROCESS_POST.timer(() -> processor.postprocessJavaAst(jCode));
                          PROCESS_POST.timer((Operation) (args) ->
                             ((QueryProcessor) args[0]).postprocessJavaAst((JavaAst) args[1]), processor, jCode);
                          qAst = (JavaAst) astManager.loadTree(wa.jastFile);
                          if (qAst == null)
-...
+             }
           };
           P2JQuery[] res = new P2JQuery[1];
           PARSE_QUERY.timer(() -> res[0] = parse(openQueryProcessor, buffers, predicate, qname, substBuffers));
           return res[0];
           return (P2JQuery) PARSE_QUERY.timer((ReturningOperation) (args) ->
              parse((QueryProcessor) args[0],
                     (List<Buffer>) args[1],
                     (String) args[2],
                     (String) args[3],
                     (List<Buffer>) args[4]),
              openQueryProcessor, buffers, predicate, qname, substBuffers);
+       }
        /**
-...
+                }
              };
              P2JQuery[] res = new P2JQuery[1];
              String pred = predicate;
              PARSE_FIND.timer(() -> res[0] = parse(findQueryProcessor, buffers, pred, qname, substBuffers));
              return res[0];
              return (P2JQuery) PARSE_FIND.timer((ReturningOperation) (args) ->
                 parse((QueryProcessor) args[0],
                       (List<Buffer>) args[1],
                       (String) args[2],
                       (String) args[3],
                       (List<Buffer>) args[4]),
                 findQueryProcessor, buffers, predicate, qname, substBuffers);
+          }
           finally
+          {

new/src/com/goldencode/p2j/persist/FQLHelper.java 2023-02-15 16:14:07 +0000
462	462	String fwhere = StringHelper.safeTrim(where);
463	463	FQLHelper[] res = new FQLHelper[1];
464	464
465		FQL_HELPER.timer(() ->
	465	// This lamba is really big and does a lot of linking work. Try to reduce!
	466	FQL_HELPER.timer((timerArgs) ->
466	467	{
467	468	try
468	469	{

new/src/com/goldencode/p2j/persist/OutputDataSetCopier.java 2023-02-15 16:14:46 +0000
108	108	@Override
109	109	public void finished()
110	110	{
111		COPIER.timer(() -> srcDS.performOutputCopy(outputParam));
	111	COPIER.timer((Operation) (args) -> ((DataSet) args[0]).performOutputCopy((DataSetParameter) args[1]), srcDS, outputParam);
112	112	}
113	113
114	114	/** No-op. */

new/src/com/goldencode/p2j/persist/OutputDataSetHandleCopier.java 2023-02-15 16:15:06 +0000
133	133	@Override
134	134	public void finished()
135	135	{
136		COPIER.timer(() -> finishedImpl());
	136	COPIER.timer((Operation) (args) -> finishedImpl());
137	137	}
138	138
139	139	/** Copies data in OUTPUT direction in DataSet-handle parameter case. */

new/src/com/goldencode/p2j/persist/OutputTableCopier.java 2023-02-15 16:15:45 +0000
104	104	@Override
105	105	public void finished()
106	106	{
107		COPIER.timer(() -> srcBuf.performOutputCopy(outputParam));
	107	COPIER.timer((Operation) (args) ->
	108	((TemporaryBuffer) args[0]).performOutputCopy((TableParameter) args[1]), srcBuf, outputParam);
108	109	}
109	110
110	111	/** No-op. */

new/src/com/goldencode/p2j/persist/OutputTableHandleCopier.java 2023-02-15 16:15:57 +0000
127	127	@Override
128	128	public void finished()
129	129	{
130		COPIER.timer(() -> finishedImpl());
	130	COPIER.timer((Operation) (args) -> finishedImpl());
131	131	}
132	132
133	133	/** Copies data in OUTPUT direction in table-handle parameter case.*/

           translateWhere();
           Operation oper = () ->
           Operation oper = (args) ->
+          {
              // need to put together order by clause first, as the sort criteria determined in this analysis may be
              // needed when composing the from-clause and where clause
              List<SortCriterion> sortCriteria = assembleOrderByClause();
              StringBuilder sb = (StringBuilder) args[0];
              assembleSelectClause(buf);
              assembleFromClause(buf, sortCriteria);
              buf.append(assembleWhereClause(sortCriteria).toFinalExpression());
              generateOrderBy(sortCriteria, buf);
              assembleSelectClause(sb);
              assembleFromClause(sb, sortCriteria);
              sb.append(assembleWhereClause(sortCriteria).toFinalExpression());
              generateOrderBy(sortCriteria, sb);
           };
           QUERY_ASSEMBLE.timer(oper);
           QUERY_ASSEMBLE.timer(oper, buf);
           return buf.toString().trim();
+       }

new/src/com/goldencode/p2j/persist/RecordBuffer.java 2023-02-15 16:34:36 +0000
2020	2020	{
2021	2021	Buffer[] res = new Buffer[1];
2022	2022
2023		DEF_BUFFER.timer(() ->
	2023	// TODO there are too many fields linked to this lambda; reduce
	2024	DEF_BUFFER.timer((args) ->
2024	2025	{
2025	2026	RecordBuffer buffer = new RecordBuffer(def, dmoBufIface, database, null);
2026	2027	buffer.initialize();
...	...
2165	2166	{
2166	2167	Buffer[] res = new Buffer[1];
2167	2168
2168		DEF_BUFFER.timer(() ->
	2169	// TODO: too many lambda references
	2170	DEF_BUFFER.timer((Operation) (args) ->
2169	2171	{
2170	2172	RecordBuffer buffer = new RecordBuffer(def, dmoBufIface, database, variable, blockDepth);
2171	2173

new/src/com/goldencode/p2j/persist/RuntimeJastInterpreter.java 2023-02-15 16:20:05 +0000
422	422	Aast aMethod = classMethods.get(methodName);
423	423	if (aMethod != null)
424	424	{
425		Object[] res = new Object[1];
426		QUERY_INTERPRET.timer(() -> res[0] = execMethod(aMethod, args));
427		return res[0];
	425	// this lambda is linked to the args parameter
	426	return QUERY_INTERPRET.timer((ReturningOperation) (opArgs) -> execMethod(aMethod, args));
428	427	}
429	428	throw new InterpreterException("No such method defined", null, null);
430	429	}

new/src/com/goldencode/p2j/persist/TableMapper.java 2023-02-15 16:20:38 +0000
1650	1650	*/
1651	1651	static void mapTemporaryTable(TempTable table)
1652	1652	{
1653		MAP.timer(() ->
	1653	MAP.timer((Operation) (args) ->
1654	1654	{
1655		TempTableMapper mapper = locateTemp(table);
	1655	TempTableMapper mapper = locateTemp((TempTable) args[0]);
1656	1656
1657	1657	synchronized (mapper)
1658	1658	{
1659		mapper.mapClass(table);
	1659	mapper.mapClass((TempTable) args[0]);
1660	1660	}
1661		});
	1661	}, table);
1662	1662	}
1663	1663
1664	1664	/**

new/src/com/goldencode/p2j/persist/TempTableBuilder.java 2023-02-15 16:26:28 +0000
2491	2491	}
2492	2492	}
2493	2493
2494		boolean[] res = new boolean[1];
2495		CREATE_DYN_TT.timer(() -> res[0] = DynamicTablesHelper.getInstance().createDynamicDMO(this, tableName));
2496		if (res[0])
	2494	boolean res = (boolean) CREATE_DYN_TT.timer((ReturningOperation) (args) ->
	2495	DynamicTablesHelper.getInstance().createDynamicDMO((TempTableBuilder) args[0], (String) args[1]),
	2496	this, tableName);
	2497	if (res)
2497	2498	{
2498	2499	super.name(new character(tableName)); // also makes table "prepared"
2499	2500	createDefaultBuffer();
2500	2501
2501	2502	if (beforeName != null)
2502	2503	{
2503		res[0] = createBeforeTable(beforeName);
	2504	res = createBeforeTable(beforeName);
2504	2505	}
2505	2506
2506	2507	if (beforeTableType == BeforeType.UNKNOWN)
...	...
2513	2514	forceClear();
2514	2515	}
2515	2516
2516		return new logical(res[0]);
	2517	return new logical(res);
2517	2518	}
2518	2519
2519	2520	/**

+       {
           TempTableBuffer[] res = new TempTableBuffer[1];
           DEF_BUFFER.timer(() ->
           // too many lambda references, reduce
           DEF_BUFFER.timer((args) ->
+          {
              TemporaryBuffer buffer = makeBuffer(def, dmoBufIface, variable, global, new DefaultUndoState(true));
-...
+       {
           TempTableBuffer[] res = new TempTableBuffer[1];
           DEF_BUFFER.timer(() ->
           // too many lambda links, reduce
           DEF_BUFFER.timer((args) ->
+          {
              TemporaryBuffer buffer = makeBuffer(def, dmoBufIface, variable, global, undoable, blockDepth);
-...
+       {
           TempTableBuffer[] res = new TempTableBuffer[1];
           DEF_BUFFER.timer(() ->
+          {
              res[0] = defineImpl(def, template, variable, legacyName, blockDepth, shared, mutable);
           });
           return (T) res[0];
           // TODO remap define parameters through the lambda args
           return (T) DEF_BUFFER.timer((ReturningOperation) (args) ->
              defineImpl(def, template, variable, legacyName, blockDepth, shared, mutable)
           );
+       }
        /**
-...
         */
        public static void associate(final TableParameter src, Temporary dstDMO, ParameterOption option)
+       {
           STATIC_PARAM.timer(() -> associateImpl(src, dstDMO, EnumSet.of(option)));
           STATIC_PARAM.timer((Operation) (args) -> associateImpl(
                    (TableParameter) args[0],
                    (Temporary) args[1],
                    (EnumSet<ParameterOption>) args[2]),
                 src, dstDMO, EnumSet.of(option));
+       }
        /**
-...
         */
        public static void associate(TableParameter src, Temporary dstDMO, EnumSet<ParameterOption> options)
+       {
           STATIC_PARAM.timer(() -> associateImpl(src, dstDMO, options));
           STATIC_PARAM.timer((Operation) (args) -> associateImpl(
                    (TableParameter) args[0],
                    (Temporary) args[1],
                    (EnumSet<ParameterOption>) args[2]),
                 src, dstDMO, options);
+       }
        /**
-...
         */
        public static void createDynamicTable(TableParameter src, handle target, ParameterOption option)
+       {
           DYN_PARAM.timer(() -> createDynamicTableImpl(src, target, option));
           DYN_PARAM.timer((Operation) (args) -> createDynamicTableImpl(
                    (TableParameter) args[0],
                    (handle) args[1],
                    (ParameterOption) args[2]),
                 src, target, option);
+       }
        /**
-...
                                                                 TempTable tempTable)
+       {
           Temporary[] temporary = new Temporary[1];
           CREATE_BUFFER.timer(() ->
           // TODO: too many lambda links; reduce
           CREATE_BUFFER.timer((args) ->
+          {
              final BufferManager bufferManager = master != null ? master.bufferManager : BufferManager.get();
              String uniqueBufferName = bufferManager.generateUniqueBufferName(bufferName);

new/src/com/goldencode/p2j/persist/orm/Query.java 2023-02-15 16:27:57 +0000
345	345	{
346	346	if (sqlQuery == null)
347	347	{
348		Operation op = () ->
	348	// TODO: lots of references inside this lambda: reduce
	349	Operation op = (args) ->
349	350	{
350	351	FqlToSqlConverter fql2sql = FqlToSqlConverter.getInstance(dialect, db, params);
351	352	rowStructure = new ArrayList<>(2); // this should be enough for most cases

              log(() -> "FWD ORM: " + stmt);
              ResultSet[] resultSetArray = new ResultSet[1];
              SQLStatementLogger.getLogger().
                 log(session.getDatabase(), stmt, () -> resultSetArray[0] = stmt.executeQuery());
              SQLStatementLogger.getLogger().log(session.getDatabase(), stmt, (args) -> resultSetArray[0] = stmt.executeQuery());
              ResultSet resultSet = resultSetArray[0];
              reportSQLWarnings(session);
-...
              log(() -> "FWD ORM: " + stmt);
              ResultSet[] resultSetArray = new ResultSet[1];
              SQLStatementLogger.getLogger().
                 log(session.getDatabase(), stmt, () -> resultSetArray[0] = stmt.executeQuery());
              SQLStatementLogger.getLogger().log(session.getDatabase(), stmt, (args) -> resultSetArray[0] = stmt.executeQuery());
              ResultSet resultSet = resultSetArray[0];
              return new ScrollableResults<>(stmt, resultSet, rowStructure, session);
-...
              log(() -> "FWD ORM: " + stmt);
              ResultSet[] resultSetArray = new ResultSet[1];
              SQLStatementLogger.getLogger().
                 log(session.getDatabase(), stmt, () -> resultSetArray[0] = stmt.executeQuery());
              SQLStatementLogger.getLogger().log(session.getDatabase(), stmt, (args) -> resultSetArray[0] = stmt.executeQuery());
              ResultSet resultSet = resultSetArray[0];
              reportSQLWarnings(session);
-...
              log(() -> "FWD ORM: " + stmt);
              int[] result = new int[1];
              SQLStatementLogger.getLogger().
                 log(session.getDatabase(), stmt, () -> result[0] = stmt.executeUpdate());
              SQLStatementLogger.getLogger().log(session.getDatabase(), stmt, (args) -> result[0] = stmt.executeUpdate());
              return result[0];
+          }
-...
              log(() -> "FWD ORM: " + stmt);
              ResultSet[] resultSetArray = new ResultSet[1];
              SQLStatementLogger.getLogger().
                 log(session.getDatabase(), stmt, () -> resultSetArray[0] = stmt.executeQuery());
                 log(session.getDatabase(), stmt, (args) -> resultSetArray[0] = stmt.executeQuery());
              ResultSet resultSet = resultSetArray[0];
-...
                                        Session session)
        throws PersistenceException
+       {
           BaseRecord[] res = new BaseRecord[1];
           HYDRATE_RECORD.timer(() -> res[0] = hydrateRecordImpl(resultSet, rowStructure, rsOffset, session));
           return res[0];
           return (BaseRecord) HYDRATE_RECORD.timer((ReturningOperation) (args) ->
                 hydrateRecordImpl(
                          (ResultSet) args[0],
                          (RowStructure) args[1],
                          (int) args[2],
                          (Session) args[3]),
              resultSet, rowStructure, rsOffset, session);
+       }
        /**

     import com.goldencode.p2j.jmx.FwdJMX;
     import com.goldencode.p2j.jmx.NanoTimer;
     import com.goldencode.p2j.jmx.Operation;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.LogHelper;
-...
+       {
           if (session != null && activeBlock != null)
+          {
              NO_UNDO_TRACE.timer(() -> {
              // going to be removed anyways
              NO_UNDO_TRACE.timer((args) -> {
                 SQLRedo.Insert redo = new SQLRedo.Insert(session.getPersister(), dmo.deepCopy());
                 redoable.add(redo);
              });
-...
+       {
           if (session != null && activeBlock != null && dmo.checkState(CHANGED))
+          {
              NO_UNDO_TRACE.timer(() -> {
              // going to be removed anyways
              NO_UNDO_TRACE.timer((args) -> {
                 SQLRedo.Update redo = new SQLRedo.Update(session.getPersister(), dmo.deepCopy());
                 redoable.add(redo);
              });
-...
+       {
           if (session != null && activeBlock != null)
+          {
              NO_UNDO_TRACE.timer(() -> {
              // going to be removed anyways
              NO_UNDO_TRACE.timer((args) -> {
                 SQLRedo.Delete redo = new SQLRedo.Delete(session.getPersister(), dmoClass, id);
                 redoable.add(redo);
              });
-...
+       {
           if (session != null && activeBlock != null)
+          {
              NO_UNDO_TRACE.timer(() -> {
              // going to be removed anyways
              NO_UNDO_TRACE.timer((args) -> {
                 SQLRedo.BulkUpdate redo = new SQLRedo.BulkUpdate(session, query);
                 redoable.add(redo);
              });
-...
           // let the noUndoRolledBack flag check here to avoid profiling disabled redo
           if (session != null && lastActiveBlock != null && lastActiveBlock.noUndoRolledBack)
+          {
              REDO.timer(() -> lastActiveBlock.maybeReapplyNoUndo(session));
              // going to be removed anyways
              REDO.timer((Operation) (args) -> lastActiveBlock.maybeReapplyNoUndo(session));
+          }
           // reactivate the next block in the stack (if any)

new/src/com/goldencode/p2j/persist/orm/UnclosablePreparedStatement.java 2023-02-15 16:32:12 +0000
468	468	{
469	469	Object[] res = new Object[1];
470	470	SQLException[] exc = new SQLException[1];
471		EXEC.timer(() ->
	471	// TODO use lambda args
	472	EXEC.timer((args) ->
472	473	{
473	474	try
474	475	{

         * @return  Context local variable.
         */
        public final T get(boolean create)
+       {
           Object[] res = new Object[1];
           GET.timer(() -> res[0] = getImpl(create));
           return (T) res[0];
+       {
           return (T) GET.timer((ReturningOperation) (args) -> getImpl((boolean) args[0]), create);
+       }
        /**

           environments = readList(in, (Supplier<EnvironmentColorTable>) EnvironmentColorTable::new);
           deadFrames = readIntArray(in);
           NANO_TIMER.timer(() ->
           NANO_TIMER.timer((args) ->
+          {
              setWidgetAttrIds((int[]) PayloadSerializer.readPayload(in));
              setWidgetAttrValues((Object[]) PayloadSerializer.readPayload(in));
           });
              setWidgetAttrIds((int[]) PayloadSerializer.readPayload((ObjectInput) args[0]));
              setWidgetAttrValues((Object[]) PayloadSerializer.readPayload((ObjectInput) args[0]));
           }, in);
+       }
        /**
-...
           writeIntArray(out, deadFrames);
           NANO_TIMER.timer(() ->
           NANO_TIMER.timer((args) ->
+          {
              PayloadSerializer.writePayload(out, widgetAttrIds);
              PayloadSerializer.writePayload(out, widgetAttrValues);
           });
              PayloadSerializer.writePayload((ObjectOutput) args[0], args[1]);
              PayloadSerializer.writePayload((ObjectOutput) args[0], args[2]);
           }, out, widgetAttrIds, widgetAttrValues);
+       }
+    }

new/src/com/goldencode/p2j/util/LegacyJavaAppserver.java 2023-02-15 16:33:18 +0000
963	963	@Override
964	964	public void addTableMetaData(DataObject metaData, DataObject table)
965	965	{
966		TABLE_META.timer(() -> DataSetSDOHelper.addTableMetaData(metaData, table));
	966	TABLE_META.timer((Operation) (args) ->
	967	DataSetSDOHelper.addTableMetaData((DataObject) args[0], (DataObject) args[1]), metaData, table);
967	968	}
968	969
969	970	/**
...	...
1041	1042	{
1042	1043	LegacyJavaAppserverParameter[] res = new LegacyJavaAppserverParameter[1];
1043	1044
1044		JAVA_PARAM.timer(() ->
	1045	// TODO: Huge lambda; try to reduce!
	1046	JAVA_PARAM.timer((args) ->
1045	1047	{
1046	1048	Object value = pvalue;
1047	1049	Object orig = value;
...	...
1188	1190	{
1189	1191	Object[] res = new Object[1];
1190	1192
1191		OUTPUT_PARAM.timer(() ->
	1193	// TODO: huge lambda; try to reduce
	1194	OUTPUT_PARAM.timer((args) ->
1192	1195	{
1193	1196	int type = param.getType();
1194	1197	Object arg = param.getValue();

new/src/com/goldencode/p2j/util/TransactionManager.java 2023-02-15 16:33:46 +0000
6653	6653	return;
6654	6654	}
6655	6655
6656		ROLLBACK.timer(() ->
	6656	// TODO: huge lambda; try to reduce
	6657	ROLLBACK.timer((args) ->
6657	6658	{
6658	6659	if (LOG.isLoggable(Level.FINE))
6659	6660	{
...	...
6751	6752	{
6752	6753	return;
6753	6754	}
6754
6755		COMMIT.timer(() ->
	6755
	6756	// TODO: huge lambda; try to reduce
	6757	COMMIT.timer((args) ->
6756	6758	{
6757	6759	if (LOG.isLoggable(Level.FINE))
6758	6760	{
...	...
7070	7072	private static void processValidate(WorkArea wa)
7071	7073	throws ErrorConditionException
7072	7074	{
7073		VALIDATE.timer(() ->
	7075	// TODO: huge lambda; try to reduce
	7076	VALIDATE.timer((args) ->
7074	7077	{
7075	7078	if (LOG.isLoggable(Level.FINE))
7076	7079	{

Project

General

Profile

FWD » Core Development » Base Language