# Property.java

    /*
    ** Module   : Property.java
    ** Abstract : Implementation of the Progress.Reflect.Property 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.
    ** 003 ME  20230905 Removed 4gl ctor.
    ** 004 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.
    ** 005 ES  20250521 Added runtime support for Progress.Reflect.Property.
    */

    /*
    ** 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.oo.lang.*;
    import com.goldencode.p2j.util.*;

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

    import java.lang.reflect.*;

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

       private logical canRead = TypeFactory.logical();

       private logical canWrite = TypeFactory.logical();

       private logical isAbstract = TypeFactory.logical();

       private logical isIndexed = TypeFactory.logical();

       private logical isOverride = TypeFactory.logical();

       private object<? extends AccessMode> setterAccessMode = new object<>(AccessMode.class);

       private InternalEntry getter = null;

       private InternalEntry setter = null;

       /**
        * Create a new legacy class object.
        *
        * @param    cls
        *           The originating legacy class.
        * @param    field
        *           The field (reflection).
        * @param    getter
        *           The method (reflection).
        * @param    setter
        *           The method (reflection).
        *
        */
       public Property (LegacyClass cls, Field field, Method getter, Method setter)
       {
          super(cls, getter, setter);

          this.canRead.assign(getter != null);
          this.canWrite.assign(setter != null);
          this.isAbstract.assign(field == null);

          object<? extends LegacyClass> superClass = getOriginatingClass().ref().getSuperClass();
          object<? extends Property> parentProperty = !superClass.isUnknown() ? superClass.ref().getProperty(getName()) :
                                                                                new object<>();

          this.isOverride.assign(!parentProperty.isUnknown());

          this.getterAccessMode.assign(getter != null ? AccessMode.getEnum(getter.getModifiers()) : new object<>(AccessMode.class));
          this.setterAccessMode.assign(setter != null ? AccessMode.getEnum(setter.getModifiers()) : new object<>(AccessMode.class));
          this.getter = SourceNameMapper.buildInternalEntry(_getSignature(getter,  InternalEntry.Type.GETTER), getter);
          this.setter = SourceNameMapper.buildInternalEntry(_getSignature(setter,  InternalEntry.Type.SETTER), setter);
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Reflect.AccessMode", type = Type.GETTER, name = "GetterAccessMode")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public object<? extends AccessMode> getGetterAccessMode()
       {
          return getterAccessMode.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "CanRead")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public logical getCanRead()
       {
          return canRead.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "CanWrite")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public logical getCanWrite()
       {
          return canWrite.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "IsAbstract")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public logical getIsAbstract()
       {
          return isAbstract.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "IsIndexed")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public logical getIsIndexed()
       {
          return isIndexed.duplicate();
       }

       @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "IsOverride")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public logical getIsOverride()
       {
          return isOverride.duplicate();
       }

       @LegacySignature(returns = "OBJECT", qualified = "Progress.Reflect.AccessMode", type = Type.GETTER, name = "SetterAccessMode")
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public object<? extends AccessMode> getSetterAccessMode()
       {
          return setterAccessMode.duplicate();
       }

       @Override
       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT")
       })
       public BaseDataType get()
       {
          if (getter == null)
          {
             String msg = String.format("Cannot access %s because it is a property that is write-only.", getName().getValue());

             ErrorManager.recordOrThrowError(13823, msg, false);
             return BaseDataType.generateUnknown(getClass());
          }

          Class<? extends _BaseObject_> cls = getDeclaringClass().ref().getJavaClass();
          Object referent = ObjectOps.getStaticInstance(cls);

          Class<?> retType = getter.getMethod().getReturnType();

          object<? extends ParameterList> _params = ObjectOps.newInstance(com.goldencode.p2j.oo.lang.ParameterList.class, "I", 0);
          ParameterList params = _params.ref();

          BaseDataType[] retVal = new BaseDataType[1];
          Runnable task = () -> retVal[0] = (BaseDataType) ControlFlowOps.invokeLegacyMethod(getter,
                      retType == void.class || retType == Void.class,
                      referent, getDeclaringClass().getTypeName(), getName().getValue(), params.getModes(), params.getArgs());

          LegacyClass.invokeImpl(params, task);

          return retVal[0];
       }

       @Override
       @LegacySignature(type = Type.METHOD, name = "Get", returns = "BDT", parameters =
       {
          @LegacyParameter(name = "instance", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT")
       })
       public BaseDataType get(final object<? extends _BaseObject_> _instance)
       {
          if (getter == null)
          {
             String msg = String.format("Cannot access %s because it is a property that is write-only.", getName().getValue());

             ErrorManager.recordOrThrowError(13823, msg, false);
             return BaseDataType.generateUnknown(getClass());
          }

          Class<?> retType = getter.getMethod().getReturnType();

          object<? extends ParameterList> _params = ObjectOps.newInstance(com.goldencode.p2j.oo.lang.ParameterList.class, "I", 0);
          ParameterList params = _params.ref();

          BaseDataType[] retVal = new BaseDataType[1];
          Runnable task = () -> retVal[0] = (BaseDataType) ControlFlowOps.invokeLegacyMethod(getter,
                      retType == void.class || retType == Void.class,
                      _instance.ref(), getOriginatingClass().getTypeName(), getName().getValue(), params.getModes(), params.getArgs());

          LegacyClass.invokeImpl(params, task);

          return retVal[0];
       }

       @LegacySignature(type = Type.METHOD, name = "Set", parameters =
       {
          @LegacyParameter(name = "value", type = "BDT", mode = "INPUT")
       })
       public void set(final Object _value)
       {
          if (setter == null)
          {
             String msg = String.format("Cannot update %s because it is a property that is read-only.", getName().getValue());

             ErrorManager.recordOrThrowError(13824, msg, false);
             return;
          }

          Class<? extends _BaseObject_> cls = getDeclaringClass().ref().getJavaClass();
          Object referent = ObjectOps.getStaticInstance(cls);

          object<? extends ParameterList> _params = ObjectOps.newInstance(com.goldencode.p2j.oo.lang.ParameterList.class, "I", 1);
          _params.ref().setParameter(new integer(1),
                                     new character(((BaseDataType) _value).getTypeName()),
                                     new character("INPUT"),
                                     BaseDataType.variable((BaseDataType) _value));
          ParameterList params = _params.ref();

          Runnable task = () -> ControlFlowOps.invokeLegacyMethod(setter,
                                                                  true,
                                                                  referent,
                                                                  getDeclaringClass().getTypeName(),
                                                                  getName().getValue(),
                                                                  params.getModes(),
                                                                  params.getArgs());

          LegacyClass.invokeImpl(params, task);
       }

       @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)
       {
          if (setter == null)
          {
             String msg = String.format("Cannot update %s because it is a property that is read-only.", getName().getValue());

             ErrorManager.recordOrThrowError(13824, msg, false);
             return;
          }

          object<? extends ParameterList> _params = ObjectOps.newInstance(com.goldencode.p2j.oo.lang.ParameterList.class, "I", 1);
          _params.ref().setParameter(new integer(1),
                                     new character(((BaseDataType) _value).getTypeName()),
                                     new character("INPUT"),
                                     BaseDataType.variable((BaseDataType) _value));
          ParameterList params = _params.ref();

          Runnable task = () -> ControlFlowOps.invokeLegacyMethod(setter,
                                                                  true,
                                                                  _instance.ref(),
                                                                  getDeclaringClass().getTypeName(),
                                                                  getName().getValue(),
                                                                  params.getModes(),
                                                                  params.getArgs());

          LegacyClass.invokeImpl(params, task);
       }

       /**
        * Get the LegacySignature annotation for the Java field.
        *
        * @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.PROPERTY)
             {
                return lsig;
             }
          }

          return null;
       }

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

          return null;
       }

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

       /**
        * Check if the field has a valid LegacySignature (type is PROPERTY).
        *
        * @param field
        *        the java method
        *
        * @return <code>true</code> if the field has a valid signature
        */
       public static boolean isSetter (Method method)
       {
          return _getSignature(method, InternalEntry.Type.SETTER) != null;
       }

       /**
        * Check if the field has a valid LegacySignature (type is PROPERTY).
        *
        * @param field
        *        the java method
        *
        * @return <code>true</code> if the field has a valid signature
        */
       public static boolean isGetter (Method method)
       {
          return _getSignature(method, InternalEntry.Type.GETTER) != null;
       }

       /**
        * Gets the access mode of the 4GL PROPERTY.
        *
        * @param javaMethod
        *        Java method (GETTER / SETTER) related to property.
        *
        * @param flags
        *        The Flags enum to use as selection criteria
        *
        * @return Flag indicating the access mode of the Property.
        */
       public static object<? extends Flags> getAccesMode(Method method)
       {
          if (Modifier.isPublic(method.getModifiers()))
          {
             return Flags.public_;
          }
          else if (Modifier.isProtected(method.getModifiers()))
          {
             return Flags.protected_;
          }
          else
          {
             return Flags.private_;
          }
       }

       /**
        * Gets the getters method of the property.
        *
        * @return See above.
        */
       public Method getter()
       {
          return getter.getMethod();
       }

       /**
        * Gets the setters method of the property.
        *
        * @return See above.
        */
       public Method setter()
       {
          return setter.getMethod();
       }

       /**
        * 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 true}.
        */
       @Override
       public boolean isTracked()
       {
          return false;
       }
    }