# Variable.java

    /*
    ** Module   : Variable.java
    ** Abstract : Implementation of the Progress.Reflect.Variable builtin class.
    **
    ** Copyright (c) 2020-2025, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- ---------------------------------------Description----------------------------------------
    ** 001 ME  20200422 First version.
    ** 002 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
    **                  signature.
    **     ME  20211028 Use 'POLY' data type for get/set methods.
    ** 003 CA  20230817 Removed ObjectOps.register, as this registration is handled by runtime.
    ** 004 ME  20230829 Mark the object as not tracked/internal, remove default 4GL ctor.
    ** 005 CA  20231130 Do not use 'TypeFactory.object' in cases where the skeleton class is not instantiated via
    **                  ObjectOps (like the reflection classes), as this will force pending ObjectOps scopeable
    **                  registration, which never gets executed, as the legacy constructors are not used.
    ** 006 ES  20250521 Added runtime support for Progress.Reflect.Variable.
    **     ES  20250527 Register the Variable object in the ObjectOps.
    */

    /*
    ** This program is free software: you can redistribute it and/or modify
    ** it under the terms of the GNU Affero General Public License as
    ** published by the Free Software Foundation, either version 3 of the
    ** License, or (at your option) any later version.
    **
    ** This program is distributed in the hope that it will be useful,
    ** but WITHOUT ANY WARRANTY; without even the implied warranty of
    ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ** GNU Affero General Public License for more details.
    **
    ** You may find a copy of the GNU Affero GPL version 3 at the following
    ** location: https://www.gnu.org/licenses/agpl-3.0.en.html
    **
    ** Additional terms under GNU Affero GPL version 3 section 7:
    **
    **   Under Section 7 of the GNU Affero GPL version 3, the following additional
    **   terms apply to the works covered under the License.  These additional terms
    **   are non-permissive additional terms allowed under Section 7 of the GNU
    **   Affero GPL version 3 and may not be removed by you.
    **
    **   0. Attribution Requirement.
    **
    **     You must preserve all legal notices or author attributions in the covered
    **     work or Appropriate Legal Notices displayed by works containing the covered
    **     work.  You may not remove from the covered work any author or developer
    **     credit already included within the covered work.
    **
    **   1. No License To Use Trademarks.
    **
    **     This license does not grant any license or rights to use the trademarks
    **     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
    **     of Golden Code Development Corporation. You are not authorized to use the
    **     name Golden Code, FWD, or the names of any author or contributor, for
    **     publicity purposes without written authorization.
    **
    **   2. No Misrepresentation of Affiliation.
    **
    **     You may not represent yourself as Golden Code Development Corporation or FWD.
    **
    **     You may not represent yourself for publicity purposes as associated with
    **     Golden Code Development Corporation, FWD, or any author or contributor to
    **     the covered work, without written authorization.
    **
    **   3. No Misrepresentation of Source or Origin.
    **
    **     You may not represent the covered work as solely your work.  All modified
    **     versions of the covered work must be marked in a reasonable way to make it
    **     clear that the modified work is not originating from Golden Code Development
    **     Corporation or FWD.  All modified versions must contain the notices of
    **     attribution required in this license.
    */

    package com.goldencode.p2j.oo.reflect;

    import com.goldencode.p2j.util.*;
    import static com.goldencode.p2j.report.ReportConstants.*;
    import static com.goldencode.p2j.util.BlockManager.*;
    import static com.goldencode.p2j.util.InternalEntry.Type;

    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.util.Objects;

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

    /**
     * Implementation of the Progress.Reflect.Variable builtin class.
     */
    @LegacyResource(resource = "Progress.Reflect.Variable")
    @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_PARTIAL)
    public class Variable
    extends BaseObject
    {
       private object<? extends AccessMode> accessMode = new object<>(AccessMode.class);

       private object<? extends DataType> dataType = new object<>(DataType.class);

       private character dataTypeName = TypeFactory.character();

       private object<? extends LegacyClass> declaringClass = new object<>(LegacyClass.class);

       private integer extent = TypeFactory.integer();

       private logical isStatic = TypeFactory.logical();

       private character name = TypeFactory.character();

       private object<? extends LegacyClass> originatingClass = new object<>(LegacyClass.class);

       private Field field;

       /**
        * Create a new legacy class object.
        *
        * @param    cls
        *           The originating legacy class.
        * @param    field
        *           The field (reflection).
        *
        */
       public Variable(LegacyClass cls, Field field)
       {
          this.name.assign(field.getName());
          this.isStatic.assign(Modifier.isStatic(field.getModifiers()));

          LegacySignature lsig = field.getAnnotation(LegacySignature.class);
          String dataType = lsig.dataType();
          this.dataType.assign(DataType.getEnum(new character(dataType)));

          this.dataTypeName.assign(character.UNKNOWN);
          if (dataType.equalsIgnoreCase("OBJECT"))
          {
             dataType = lsig.qualified();
             this.dataTypeName.assign(dataType);
          }

          this.accessMode = AccessMode.getEnum(field.getModifiers());
          this.originatingClass.assign(cls);

          int extent = lsig.extent();

          if (extent == SourceNameMapper.NO_EXTENT)
          {
             this.extent.assign(0);
          }
          else if (extent == SourceNameMapper.DYNAMIC_EXTENT)
          {
             this.extent.assign(integer.UNKNOWN);
          }
          else
          {
             this.extent.assign(extent);
          }

          Class<? extends _BaseObject_> declaringClass = (Class<? extends _BaseObject_>) field.getDeclaringClass();
          this.declaringClass.assign(ObjectOps.getLegacyClass(declaringClass));

          this.field = field;
       }

       /**
        * Create a new legacy class object.
        *
        * @param    cls
        *           The originating legacy class.
        * @param    getter
        *           The method (reflection).
        * @param    setter
        *           The method (reflection).
        *
        */
       public Variable(LegacyClass cls, Method getter, Method setter)
       {
          object<? extends Flags> getterModeFlag = getter != null ? Property.getAccesMode(getter) :
                                                                    new object<>(Flags.private_);
          object<? extends Flags> setterModeFlag = setter != null ? Property.getAccesMode(setter) :
                                                                    new object<>(Flags.private_);

          Method inferedMethod = null;
          boolean inferGetter = false;

          if (getterModeFlag.compareTo(setterModeFlag) <= 0)
          {
             inferedMethod = getter != null ? getter : setter;
             inferGetter = getter != null ? true : false;
          }
          else
          {
             inferedMethod = setter != null ? setter : getter;
             inferGetter = setter != null ? false : true;
          }

          LegacySignature lsig = inferedMethod.getAnnotation(LegacySignature.class);

          this.name.assign(lsig.name());
          this.isStatic.assign(Modifier.isStatic(inferedMethod.getModifiers()));
          this.accessMode = AccessMode.getEnum(inferedMethod.getModifiers());

          this.originatingClass.assign(cls);

          Class<? extends _BaseObject_> declaringClass = (Class<? extends _BaseObject_>) inferedMethod.getDeclaringClass();
          this.declaringClass = ObjectOps.getLegacyClass(declaringClass);

          this.dataTypeName.assign(character.UNKNOWN);

          int extent;
          if (inferGetter)
          {
             String dataType = lsig.returns();
             this.dataType = DataType.getEnum(new character(dataType));

             if (dataType.equalsIgnoreCase("OBJECT"))
             {
                dataType = lsig.qualified();
                this.dataTypeName.assign(dataType);
             }

             extent = lsig.extent();
          }
          else
          {
             LegacyParameter[] lparameters = lsig.parameters();
             LegacyParameter   lparameter  = lparameters[0];

             String dataType = lparameter.type();
             this.dataType.assign(DataType.getEnum(new character(dataType)));

             if (dataType.equalsIgnoreCase("OBJECT"))
             {
                dataType = lsig.qualified();
                this.dataTypeName.assign(dataType);
             }

             extent = lparameter.extent();
          }

          if (extent == SourceNameMapper.NO_EXTENT)
          {
             this.extent.assign(0);
          }
          else if (extent == SourceNameMapper.DYNAMIC_EXTENT)
          {
             this.extent.assign(integer.UNKNOWN);
          }
          else
          {
             this.extent.assign(extent);
          }
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Reflect.AccessMode", type = Type.GETTER, name = "AccessMode")
       public object<? extends AccessMode> getAccessMode()
       {
          return accessMode.duplicate();
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Reflect.DataType", type = Type.GETTER, name = "DataType")
       public object<? extends DataType> getDataType()
       {
          return dataType.duplicate();
       }

       @LegacySignature(returns = "CHARACTER", type = Type.GETTER, name = "DataTypeName")
       public character getDataTypeName()
       {
          return dataTypeName.duplicate();
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Lang.Class", type = Type.GETTER, name = "DeclaringClass")
       public object<? extends LegacyClass> getDeclaringClass()
       {
          return declaringClass.duplicate();
       }

       @LegacySignature(returns = "INTEGER", type = Type.GETTER, name = "Extent")
       public integer getExtent()
       {
          return extent.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "IsStatic")
       public logical getIsStatic()
       {
          return isStatic.duplicate();
       }

       @LegacySignature(returns = "CHARACTER", type = Type.GETTER, name = "Name")
       public character getName()
       {
          return name.duplicate();
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Lang.Class", type = Type.GETTER, name = "OriginatingClass")
       public object<? extends LegacyClass> getOriginatingClass()
       {
          return originatingClass.duplicate();
       }

       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT")
       public Object get()
       {
          object<? extends _BaseObject_> cls = new object<>(declaringClass.ref().getJavaClass());

          return get(cls);
       }

       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT", parameters =
       {
          @LegacyParameter(name = "index", type = "INTEGER", mode = "INPUT")
       })
       public Object get(final integer _index)
       {
          UnimplementedFeature.missing("Progress.Reflect.Variable:get(integer)");

          return new Object();
       }

       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT")
       })
       public Object get(final object<? extends _BaseObject_> _instance)
       {
          _BaseObject_ instance = _instance.ref();
          Class<?> clazz = declaringClass.ref().getJavaClass();

          Object getResult = null;

          try
          {
             Object castedInstance = clazz.cast(instance);
             getResult = field.get(castedInstance);
          }
          catch (ClassCastException exe)
          {
             ErrorManager.recordOrThrowError(18191, "The class instance for executing code via a reflection object must be the same"
                                             + " type as either the Originating or the Declaring class", false);
          }
          catch (IllegalArgumentException | IllegalAccessException e)
          {
             throw new ErrorConditionException(e);
          }

          return getResult;
       }

       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
          @LegacyParameter(name = "index", type = "INTEGER", mode = "INPUT")
       })
       public Object get(final object<? extends _BaseObject_> _instance, final integer _index)
       {
          UnimplementedFeature.missing("Progress.Reflect.Variable:get(object, integer)");

          return new Object();
       }

       @LegacySignature(type = Type.METHOD, name = "Set", parameters =
       {
          @LegacyParameter(name = "value", type = "BDT", mode = "INPUT")
       })
       public void set(final Object _value)
       {
          object<? extends _BaseObject_> cls = new object<>(declaringClass.ref().getJavaClass());

          if (!isStatic.booleanValue())
          {
             String msg = "TO Get/Set instance Variable/Property " + name.getValue()
                          + ",you should use the overload that takes an object instance parameter.";
             ErrorManager.recordOrThrowError(18190, msg, false);
             return;
          }

          set(cls);
       }

       @LegacySignature(type = Type.METHOD, name = "Set", parameters =
       {
          @LegacyParameter(name = "index", type = "INTEGER", mode = "INPUT"),
          @LegacyParameter(name = "value", type = "BDT", mode = "INPUT")
       })
       public void set(final integer _index, final Object _value)
       {
          UnimplementedFeature.missing("Progress.Reflect.Variable:set(integer, Object)");
       }

       @LegacySignature(type = Type.METHOD, name = "Set", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
          @LegacyParameter(name = "value", type = "BDT", mode = "INPUT")
       })
       public void set(final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> _instance, final Object _value)
       {
          _BaseObject_ instance = _instance.ref();
          Class<? extends _BaseObject_> clazz = declaringClass.ref().getJavaClass();

          BaseDataType value = (BaseDataType) _value;

          try
          {
             _BaseObject_ castedInstance = clazz.cast(instance);

             BaseDataType variable = (BaseDataType) field.get(castedInstance);
             boolean isExtent = extent.intValue() != -1;

             character dataTypeName = dataType.ref().toLegacyString();
             Call.setterAssignment(variable, value, dataTypeName.getValue(), isExtent);
          }
          catch (ClassCastException exe)
          {
             ErrorManager.recordOrThrowError(18191, "The class instance for executing code via a reflection object must be the same"
                                                    + " type as either the Originating or the Declaring class", false);
          }
          catch (IllegalArgumentException | IllegalAccessException e)
          {
             throw new ErrorConditionException(e);
          }
       }

       @LegacySignature(type = Type.METHOD, name = "Set", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
          @LegacyParameter(name = "index", type = "INTEGER", mode = "INPUT"),
          @LegacyParameter(name = "value", type = "BDT", mode = "INPUT")
       })
       public void set(final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> _instance, final integer _index, Object _value)
       {
          UnimplementedFeature.missing("Progress.Reflect.Variable:set(object, integer, Object)");
       }

       /**
        * Reports if the given instance is managed as part of the legacy 4GL object life cycle. This
        * includes reference counting, linking in the SESSION object chain, managed construction and
        * destruction.
        *
        * @return   Always {@code false} for 4GL internals (class/reflection).
        */
       @Override
       public boolean isTracked()
       {
          return false;
       }

       public Field getField()
       {
          return field;
       }

       /**
        * Check if the method has a valid LegacySignature (type is method).
        * @param javaMethod the java method
        * @return <code>true</code> if the method has a valid signature
        */
       public static boolean isVariable (Field field)
       {
          return _getSignature(field) != null;
       }

       /**
        * Calculates a hash code using the instance's value.  This implementation is consistent with
        * {@code equals}, so it is usable for Java's associative collections.  It ignores the name
        * of the enum in this calculation (which is how {@code equals} is implemented as well).
        *
        * @return   The hash code for this object instance.
        */
       @Override
       public int hashCode()
       {
          return Objects.hash(name.getValue());
       }

       /**
        * Determines if this instance and the given instance are equivalent.  This implementation is consistent
        * with {@code compareTo} and {@code hashCode}, which means these instances are safe for usage as a key
        * in an associative collection.
        *
        * @param    obj
        *           The instance to compare against.
        *
        * @return   {@code true} if the objects compare equivalently; {@code false} if they do not, or if the
        *           parameter is not a {@code LegacyEnum} instance of the same subclass type.
        */
       @Override
       public boolean equals(Object obj)
       {
          if (obj == null)
          {
             return false;
          }

          Variable other = (Variable) obj;
          return name.equals(other);
       }

       /**
        * Get the LegacySignature annotation for the Java method.
        *
        * @param   field
        *          The field.
        * @return  The annotation if present or null.
        */
       private static LegacySignature _getSignature(Field field)
       {
          if (field != null)
          {
             LegacySignature lsig = field.getAnnotation(LegacySignature.class);
             if (lsig != null && lsig.type() == InternalEntry.Type.VARIABLE)
             {
                return lsig;
             }
          }

          return null;
       }
    }