FWD » Core Development » Base Language

**     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)

         {

**                           - for typed FUNCTION calls, convert the returned value to the expected type.

**                           - fixed caching issues when the call does not complete due to errors or for 

**                           recursive calls.

*/

/*

            caller.callerInstance = reference;

            caller.wa = wa;

            caller.mthd = lastInvoke.method;

            caller.methodName = lastInvoke.method.getName();

            caller.ie = null;

            caller.iename = cfg.getTarget();

                  try

                  {

                     res = checkInvokeResult(res, iename, cfg.isFunction(), cfg.isDynamicFunction());

                     if (cls != null && cfg.isFunction())

      boolean externalProcedure = caller.getPhandle() == null;

      Object instance = externalProcedure ? caller.getClassName() : caller.getCallerInstance();

      Method mthd = externalProcedure ? null : caller.mthd;

      if (args != null && args.length > 0)

      {

                                                       eventProcedureName,

                                                       eventProcedureContext,

                                                       instance,

                                                       argumentTypes);

      Map<InvokeConfig, LastInvokeDetails> thisCallSite = 

      private final Method method;

      /**

       * Create a new instance.

       * 

       * @param    legacyName

       *           {@link #method} is being invoked.

       * @param    method

       *           The Java method to invoke.

       * @param    argumentTypes

       *           The argument types for this call.

       */

                               Object     eventProcedureContext,

                               Object     reference,

                               Method     method,

                               Class<?>[] argumentTypes)

      {

         this.legacyName = legacyName;

         this.reference = (reference == null ? null : new WeakReference<>(reference));

         this.method = method;

      }

      /**

      protected WorkArea wa;

      /** The {@link Method} instance for this internal entry. */

      /** The handle associated with the {@link #callerInstance}. */

      private handle phandle;

      /** Worker which performs the {@link ProcedureManager.ProcedureHelper#pushCalleeInfo} call. */

      private Runnable pushWorker;

      /**

       * Basic c'tor.

       * 

            pushWorker.run();

            wa.bm.markPendingDynCall();

            {

            }

            else

            {

                  if (value.method != null)

                  {

                     caller.mthd = value.method;

                  }

                  return value.returnValue;

                  method = cls.getMethod(caller.methodName, signature);

                  rv = ArgValidationErrors.NO_ERROR;

                  caller.mthd = value.method;

                  return rv;

               }

                  method = cls.getDeclaredMethod(caller.methodName, signature);

                  rv = ArgValidationErrors.NO_ERROR;

                  caller.mthd = value.method;

                  return rv;

               }

                  extentInfo[0] = parExtent ? paramExtent : 0;

                  // cache failed result as well, so we don't need to repeat validation

                  return rv;

               }

               if (value == null)

               {

               }

               caller.mthd = value.method;

               return rv;

            }

              : ArgValidationErrors.INCORRECT_TYPES;

         // cache failed result as well, so we don't need to repeat validation

         return rv;

      }

       * @param   method

       *          Method found matching a given name and signature, or {@code null} if no

       *          match was found.

       * @param   returnValue

       *          Enumerated return value for {@link #valid(boolean, String, int[], Object...)}

       *          method.

       * @return  the created cache.

       */

      private static CacheValue putCache(CacheKey key,

      {

         synchronized (cache)

         {

         /** Method, if any, else <code>null</code> if none was found */

         final Method method;

         /** 

          * Enumerated return value for {@link 

          * 

          * @param   method

          *          Method, if any, else <code>null</code> if none was found.

          * @param   returnValue

          *          Enumerated return value for {@link

          *          InternalEntryCaller#valid(boolean, String, int[], Object...)}.

          *          Flag indicating whether signature of caller's parameters exactly matches

          *          method.

          */

         {

            this.method = method;

            this.returnValue = returnValue;

            this.exactMatch = exactMatch;

         }

       * 

       * @param    wa

       *           The context-local state in {@link WorkArea}.

       * @param    className

       *           The class name associated with the external program.

       * @param    persistent

       * @throws   Exception

       *           If the class can't be resolved. 

       */

      throws Exception

      {

         super(wa);

         this.methodName = "execute";

         this.className = className;

               wa.currentInvoke = null;

               res = new MapToNotFound(wa, mapTo);

            }

            res.ie = ie;

            return res;

         }

            caller = new InternalEntryCaller(wa, hcaller, ie.jname, ieName);

            caller.ie = ie;

         }

         /*

         else if (!superCall)

               // name to any errors generated during instantiation (i.e. shared vars error msgs 

               // need to know the procedure name where they are defined, if an error happens)

               wa.pm.setInstantingExternalProgram(name);

            }

            catch (Throwable t)

            {

** 016 ME  20200810 Added qualified name support in signature processing.

**     CA  20210218 Fixed signature processing for qualified return type.

**     CA  20220909 Fixed TABLE-HANDLE, DATASET, DATASET-HANDLE parameters reported by GET-SIGNATURE.

*/

/*

import java.lang.reflect.*;

import java.util.*;

import com.goldencode.p2j.util.SourceNameMapper.ExternalProgram;

    * Flag indicating if this is a IN SUPER internal entry (when set to <code>true</code>).

    * Gets its permanent value when internal entry is initialized by {@link SourceNameMapper}.

    */

   /** 

    * Flag indicating if this is a IN handle internal entry (when set to <code>true</code>).

    * Gets its permanent value when internal entry is initialized by {@link SourceNameMapper}.

    */

   /** 

    * Flag indicating if this is a PRIVATE internal entry (when set to <code>true</code>).

    * Gets its permanent value when internal entry is initialized by {@link SourceNameMapper}.

    */

   /** The return type's extent. */

   private int extent = SourceNameMapper.NO_EXTENT;

    */

   private Method method = null;

   /** The OS library name, if this is a native method. */

   private String libname = null;

    */

   public Method getMethod()

   {

      {

      }

      return method;

   }

   /**

    * Get the value of the given attribute.  If the attribute is null or

    * is not set, return <code>null</code>.

    * 

   }

   /**

    * Set the external program for this entry.

    * 

    * @param    extprog

**                           initialized at server startup, the 'initMappingData' calls were removed from the

**                           APIs.

**     CA  20220609          Fixed a regression in destructor processing.

*/

/*

import com.goldencode.p2j.oo.lang.*;

import com.goldencode.p2j.rest.*;

import com.goldencode.p2j.soap.*;

import com.goldencode.p2j.security.*;

/**

         throw new RuntimeException(e);

      }

      Method[] methods = cls.getDeclaredMethods();

      for (Method mthd : methods)

      {

            if (ie != null)

            {

               ie.setMethod(mthd);

            }

         }

      }

      InternalEntry main = null;

      /**

       * Basic c'tor.

       * 

       * @param    pname

**     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)

               {

               }

            }