FWD » Core Development » Runtime Infrastructure

**     CA  20221010          Performance improvements - avoid the ProcedureData lookup, by keeping a parallel 

**                           stack of this data for THIS-PROCEDURE.  Refs #6826

**     OM  20221103          New class names for FQLPreprocessor, FQLExpression, FQLBundle, and FQLCache.

*/

/*

    * purposes.

    */

   private final class Handler

   {

      /** Exception thrown during validation of no-undo temp-tables, which must be deferred */

      private ValidationException deferredValidationError = null;

       *          The target proxy object.

       * @param   method 

       *          The method to be executed.

       * @param   args 

       *          The method arguments.

       *

       * @throws  Throwable

       *          For various reasons, like illegal access to fields, illegal arguments or target.

       */

      throws Throwable

      {

         Object result = null;

            Class<?> declClass = method.getDeclaringClass();

            if (declClass.equals(BufferReference.class) || declClass.equals(Object.class))

            {

            }

            // TODO: use something more reliable (but efficient) here to determine whether this is a setter

            // to ensure all validation and flushing is tracked properly

            if (creatingBuffer != null && currentRecord != null && isSetter)

            {

               return creatingBuffer.handler.invoke(proxy, method, args);

            }

            // if a temporary record is set, use it to back the invocation

            if (tempRecord != null)

            {

            }

            if (isSetter)

            }

            // invoke the method on the concrete DMO implementation

            if (writeSnapshot != null && !currentRecord.checkState(DmoState.CHANGED))

            {

                  if (!ok)

                  {

                     // the assign trigger vetoed: rolling back the change

                     processChange = false;

                  }

               }

    * {@link RecordBuffer} proxies.

    */

   private static class ArgumentBuffer

   {

      /** The backing buffer of this proxy, which should handle the majority of the methods */

      private BufferImpl buffer;

       * imply the DMO alias or buffer name, which will be handled here.

       */

      @Override

      {

         try 

         {

               if (method.getName().equals("overrideName") ||

                   method.getName().equals("restoreName"))

               {

               }

               boolean overridden = buffer.overrideName(bufferName);

               try

               {

               }

               finally

               {

               if (method.getName().equals("overrideDMOAlias") ||

                   method.getName().equals("restoreDMOAlias"))

               {

               }

               boolean overridden = backBuffer.overrideDMOAlias(dmoAlias);

               try

               {

               }

               finally

               {

**     OM  20211011 Improved debugging support for proxy objects.

**     CA  20220707 Used a static 'doNotProxy' field, instead of creating the array each time.

**     GES 20210501 Upgraded table-handle parameter processing to match API changes.

*/

/*

import com.goldencode.proxy.*;

import java.lang.reflect.*;

import java.util.*;

/**

    * {@code DataSet} or will throw errors.

    */

   static class Handler

   {

      /**

       * Processes a method invocation on a proxy instance and returns the result. This method

       *          proxy instance. The declaring class of the {@code Method} object will be the

       *          interface that the method was declared in, which may be a superinterface of the

       *          proxy interface that the proxy class inherits the method through.

       * @param   args

       *          an array of objects containing the values of the arguments passed in the method

       *          invocation on the proxy instance, or {@code null} if interface method takes no

       * @see UndeclaredThrowableException

       */

      @Override

      throws Throwable

      {

         StaticDataSet dsp = (StaticDataSet) proxy;

         if (dsp.bound != null)

         {

         }

         String[] errParam = new String[1];

**     IAS 20221103          Fixed support for a binded table parameter.

**     CA  20221206          If a REFERENCE-ONLY table is already bound to the same target table, do not 

**                           re-bind. 

*/

/*

import com.goldencode.p2j.util.*;

import com.goldencode.p2j.util.ErrorManager;

import com.goldencode.p2j.util.LogHelper;

import com.goldencode.util.*;

/**

    * The handler to switch between references, when binding a definition table to another one.

    */

   private static class ReferenceProxy

   {

      /** The default properties - PK and any other properties in {@link TempRecord}. */

      private static final Map<String, String> defaultProps;

       * </ul>

       */

      @Override

      throws Throwable

      {

         Object instance = (bound == null ? def : bound);

             declClass.equals(Object.class)          ||

             HandleResource.class.isAssignableFrom(declClass))

         {

         }

         if (bound != null && boundBuffer.getDMOInterface() != defBuffer.getDMOInterface())

               Method mbound = (setter ? boundSetterByProp.get(boundProperty) 

                                       : boundGetterByProp.get(boundProperty));

               method = mbound;

            }

         }

               method.setAccessible(true);

            }

         }

         catch (Throwable t)

         {

**     RFB 20220504          Minor javadoc fixes.

**     SBI 20220504          Fixed toChar(int, String) to return -1 if key code is not represented by

**                           the given char set.

*/

/*

    * More, the maps are identity-keyed, for fast access.

    * 

    * @param    method

    *           The method to execute.

    * @param    instance

    *           The instance on which the call will be made; can be <code>null</code> for static methods.

** Module   : ProxyAssembler.java

** Abstract : Assembles a dynamic proxy subclass.

**

**

** -#- -I- --Date-- --------------------------------Description----------------------------------

** 001 ECF 20101119 Created initial version.

** 005 ECF 20160219 Added support for an optional plugin to override the assembly of arbitrary

**                  methods.

** 006 OM  20191123 Minor collection change.

*/

/*

** This program is free software: you can redistribute it and/or modify

   /** Object used to create class fields, methods, etc. */

   private final ClassWriter classWriter =

      new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

   /**

    * Constructor.

    *          interface, else <code>false</code>.  If <code>true</code>, no separate instance

    *          field will be assembled to store the invocation handler reference, as the instance

    *          of this class itself will act as the handler.

    */

   ProxyAssembler(String proxyName,

                  String parentName,

                  Class<?>[] interfaces,

                  Method[] methods,

                  ProxyAssemblerPlugin plugin,

   {

      if (plugin == null)

      {

      this.methods = methods;

      this.plugin = plugin;

      this.parentIsHandler = parentIsHandler;

   }

   /**

      }

      // create the proxy class

                        proxyName,

                        null,

                        parentName,

         // add an instance member field for the InvocationHandler

         classWriter.visitField(ACC_PRIVATE | ACC_FINAL,

                                "h",

                                null,

                                null);

      }

                                    ProxyUtils.getCaughtExceptionTypeNames(method));

         mv.visitCode();

         mv.visitMaxs(0, 0);

         mv.visitEnd();

      }

      MethodVisitor mv =

         classWriter.visitMethod(ACC_PUBLIC,

                                 "<init>",

                                 null,

                                 null);

      mv.visitFieldInsn(PUTFIELD,

                        proxyName,

                        "h",

      // return from c'tor

      mv.visitInsn(RETURN);

                           boolean parentIsHandler,

                           String proxyName)

      {

         // load invocation handler from field "h" or as "this" if the proxy

         // itself is the invocation handler

         mv.visitVarInsn(ALOAD, 0);

            mv.visitFieldInsn(GETFIELD,

                              proxyName,

                              "h",

         }

         // load "this" object ref as the first parameter for later call to

         // InvocationHandler.invoke

         mv.visitVarInsn(ALOAD, 0);

         // create new array of Objects for method's arguments or push null

         // if there are no arguments

         // call InvocationHandler.invoke

         mv.visitMethodInsn(INVOKEINTERFACE,

                            "invoke",

                            true);

         // determine method's return type

**                  equal 'doNotProxy' array, as the cache is kept in an IdentityHashMap. 

**     CA  20221006 Use a Supplier for the proxy plugin instance, as when the proxy is already created, there

**                  is no need to use this instance.  Refs #6822

*/

/*

** This program is free software: you can redistribute it and/or modify

               String proxyName = makeProxyClassName(parent, parentName);

               Method[] methods = gatherMethods(parent, proxyParent, interfaces, declaredOnly, doNotProxy);

               // assemble code for the proxy class

               ProxyAssembler asm = new ProxyAssembler(proxyName,

                                                       parentName,

                                                       interfaces,

                                                       methods,

                                                       (plugin == null ? null : plugin.get()),

               byte[] code = asm.assembleClass();

               /*

                                  ? proxyName.substring(pos + 1)

                                  : proxyName);

                  fname = fname + ".class";

                  System.out.println("Proxy class file written to: " + fname);

                  fos = new FileOutputStream(fname);

                  fos.write(code);

               if (!proxyIsHandler)

               {

               }

            }