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;
}
}