330 lines
12 KiB
Java
330 lines
12 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.gx.BImage
|
|
* javax.baja.naming.SlotPath
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.sys.Action
|
|
* javax.baja.sys.BDouble
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BLong
|
|
* javax.baja.sys.BObject
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.Property
|
|
* javax.baja.ui.table.TableModel
|
|
* javax.baja.util.Lexicon
|
|
* javax.baja.util.Version
|
|
*/
|
|
package com.tridium.program.module;
|
|
|
|
import com.tridium.program.BProgram;
|
|
import com.tridium.program.ProgramBase;
|
|
import com.tridium.program.module.BProgramModule;
|
|
import com.tridium.program.module.ComponentWriter;
|
|
import com.tridium.program.module.ReflectUtil;
|
|
import com.tridium.program.ui.BProgramEditor;
|
|
import java.lang.reflect.Method;
|
|
import javax.baja.gx.BImage;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.BDouble;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BLong;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.ui.table.TableModel;
|
|
import javax.baja.util.Lexicon;
|
|
import javax.baja.util.Version;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public abstract class ValidateModel
|
|
extends TableModel {
|
|
protected static final Lexicon lex;
|
|
public static final BImage okProgramIcon;
|
|
public static final BImage errProgramIcon;
|
|
public static final BImage warnProgramIcon;
|
|
protected static final BImage errIcon;
|
|
protected static final BImage warnIcon;
|
|
protected Array errs = new Array();
|
|
protected Array warns = new Array();
|
|
static /* synthetic */ Class class$com$tridium$program$module$BProgramModule;
|
|
|
|
public static ValidateModel make(BProgram bProgram) {
|
|
ValidateProgram validateProgram = new ValidateProgram(bProgram);
|
|
((ValidateModel)validateProgram).validate();
|
|
return validateProgram;
|
|
}
|
|
|
|
public static ValidateModel make(BProgramModule bProgramModule) {
|
|
ValidateModule validateModule = new ValidateModule(bProgramModule);
|
|
((ValidateModel)validateModule).validate();
|
|
return validateModule;
|
|
}
|
|
|
|
public BImage getProgramStatusIcon() {
|
|
if (this.getErrCount() > 0) {
|
|
return errProgramIcon;
|
|
}
|
|
if (this.getWarnCount() > 0) {
|
|
return warnProgramIcon;
|
|
}
|
|
return okProgramIcon;
|
|
}
|
|
|
|
public final int getErrCount() {
|
|
return this.errs.size();
|
|
}
|
|
|
|
public final int getWarnCount() {
|
|
return this.warns.size();
|
|
}
|
|
|
|
protected abstract void validate();
|
|
|
|
public void err(String string) {
|
|
if (!this.errs.contains((Object)string)) {
|
|
this.errs.add((Object)string);
|
|
}
|
|
}
|
|
|
|
public void warn(String string) {
|
|
if (!this.warns.contains((Object)string)) {
|
|
this.warns.add((Object)string);
|
|
}
|
|
}
|
|
|
|
public int getColumnCount() {
|
|
return 1;
|
|
}
|
|
|
|
public int getRowCount() {
|
|
return this.errs.size() + this.warns.size();
|
|
}
|
|
|
|
public Object getValueAt(int n, int n2) {
|
|
int n3 = this.getErrCount();
|
|
if (n < n3) {
|
|
return this.errs.get(n);
|
|
}
|
|
return this.warns.get(n - n3);
|
|
}
|
|
|
|
public BImage getRowIcon(int n) {
|
|
return n < this.getErrCount() ? errIcon : warnIcon;
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$program$module$BProgramModule;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$program$module$BProgramModule = ValidateModel.class("[Lcom.tridium.program.module.BProgramModule;", false);
|
|
}
|
|
lex = Lexicon.make((Class)clazz);
|
|
okProgramIcon = BImage.make((BIcon)new BProgram().getIcon());
|
|
errProgramIcon = BImage.make((BIcon)BIcon.make((BIcon)new BProgram().getIcon(), (BIcon)BIcon.std((String)"badges/error.png")));
|
|
warnProgramIcon = BImage.make((BIcon)BIcon.make((BIcon)new BProgram().getIcon(), (BIcon)BIcon.std((String)"badges/warning.png")));
|
|
errIcon = BImage.make((BIcon)BIcon.std((String)"stop.png"));
|
|
warnIcon = BImage.make((BIcon)BIcon.std((String)"warning.png"));
|
|
}
|
|
|
|
private static class ValidateProgram
|
|
extends ValidateModel {
|
|
private static final BProgramEditor pe = new BProgramEditor();
|
|
BProgram program;
|
|
|
|
public String getColumnName(int n) {
|
|
return lex.getText("vprogram.col");
|
|
}
|
|
|
|
protected void validate() {
|
|
this.checkCompileStatus();
|
|
this.checkName();
|
|
this.checkLongAndDoubleSlots();
|
|
this.checkPropertySlots();
|
|
this.checkActionDelegates();
|
|
this.checkReflection();
|
|
}
|
|
|
|
public void err(String string) {
|
|
super.err("[" + BProgramModule.toTypeName(this.program) + "] " + string);
|
|
}
|
|
|
|
public void warn(String string) {
|
|
super.warn("[" + BProgramModule.toTypeName(this.program) + "] " + string);
|
|
}
|
|
|
|
private final void checkCompileStatus() {
|
|
pe.loadValue((BObject)this.program);
|
|
int n = this.program.getCode().getChecksum();
|
|
if (n == 0 || n != pe.computeChecksum(this.program.getCode().getSource())) {
|
|
this.err(lex.getText("vprogram.err.outofdate"));
|
|
}
|
|
}
|
|
|
|
private final void checkName() {
|
|
if (BProgramModule.toComponentName(this.program) == null) {
|
|
this.err(lex.getText("vprogram.err.name"));
|
|
}
|
|
}
|
|
|
|
private final void checkLongAndDoubleSlots() {
|
|
Property[] propertyArray = this.program.getPropertiesArray();
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
BValue bValue = propertyArray[n].getDefaultValue();
|
|
if (bValue instanceof BDouble) {
|
|
this.err(lex.getText("vprogram.err.double", new Object[]{propertyArray[n].getName()}));
|
|
} else if (bValue instanceof BLong) {
|
|
this.err(lex.getText("vprogram.err.long", new Object[]{propertyArray[n].getName()}));
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void checkPropertySlots() {
|
|
Property[] propertyArray = this.program.getPropertiesArray();
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
if (ReflectUtil.getInstance().getPropertyStatus(propertyArray[n]) != 0) {
|
|
this.err(lex.getText("vprogram.err.getset", new Object[]{propertyArray[n].getName()}));
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void checkActionDelegates() {
|
|
Class<?> clazz = null;
|
|
try {
|
|
clazz = this.program.getCode().newInstance().getClass();
|
|
}
|
|
catch (Exception exception) {
|
|
return;
|
|
}
|
|
Action[] actionArray = this.program.getActionsArray();
|
|
int n = 0;
|
|
while (n < actionArray.length) {
|
|
ComponentWriter.CompAction compAction = new ComponentWriter.CompAction(actionArray[n]);
|
|
if (!"onExecute".equals(compAction.getOn())) {
|
|
String string = compAction.paramType() == null ? "" : compAction.paramType();
|
|
String string2 = compAction.getOn() + '(' + string + ')';
|
|
Object[] objectArray = new Object[]{compAction.name(), string2};
|
|
try {
|
|
Method method = clazz.getDeclaredMethod(compAction.getOn(), compAction.paramTypeArray());
|
|
if ((method.getModifiers() & 1) == 0) {
|
|
this.err(lex.getText("vprogram.err.delegate.public", objectArray));
|
|
}
|
|
}
|
|
catch (NoSuchMethodException noSuchMethodException) {
|
|
this.err(lex.getText("vprogram.err.delegate", objectArray));
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void checkReflection() {
|
|
ProgramBase programBase = this.program.getCode().newProgramInstance();
|
|
Method[] methodArray = programBase.getClass().getDeclaredMethods();
|
|
ReflectUtil reflectUtil = ReflectUtil.getInstance();
|
|
int n = 0;
|
|
while (n < methodArray.length) {
|
|
switch (reflectUtil.getOverrideStatus(methodArray[n])) {
|
|
case 2: {
|
|
this.err(lex.getText("vprogram.err.override", new Object[]{this.toMethodDef(methodArray[n])}));
|
|
break;
|
|
}
|
|
case 1: {
|
|
if ("toString".equals(methodArray[n].getName())) break;
|
|
this.warn(lex.getText("vprogram.warn.override", new Object[]{this.toMethodDef(methodArray[n])}));
|
|
break;
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final String toMethodDef(Method method) {
|
|
StringBuffer stringBuffer = new StringBuffer().append(ReflectUtil.getInstance().getDeclaringClass(method).getName()).append(".").append(method.getName()).append("(");
|
|
Class<?>[] classArray = method.getParameterTypes();
|
|
int n = 0;
|
|
while (n < classArray.length) {
|
|
if (n > 0) {
|
|
stringBuffer.append(",");
|
|
}
|
|
stringBuffer.append(classArray[n].getName());
|
|
++n;
|
|
}
|
|
stringBuffer.append(")");
|
|
return stringBuffer.toString();
|
|
}
|
|
|
|
public ValidateProgram(BProgram bProgram) {
|
|
this.program = bProgram;
|
|
}
|
|
}
|
|
|
|
private static class ValidateModule
|
|
extends ValidateModel {
|
|
BProgramModule module;
|
|
|
|
public String getColumnName(int n) {
|
|
return lex.getText("vmodule.col");
|
|
}
|
|
|
|
protected void validate() {
|
|
this.checkName();
|
|
this.checkVendor();
|
|
this.checkVersion();
|
|
if (this.module.listPrograms().length == 0) {
|
|
this.warn(lex.getText("vmodule.warn.noPrograms"));
|
|
}
|
|
}
|
|
|
|
private final void checkName() {
|
|
if (!SlotPath.isValidName((String)this.module.getModuleName())) {
|
|
this.err(lex.getText("vmodule.err.name", new Object[]{this.module.getModuleName()}));
|
|
}
|
|
}
|
|
|
|
private final void checkVendor() {
|
|
if (this.module.getVendor().length() == 0) {
|
|
this.err(lex.getText("vmodule.err.vendor"));
|
|
}
|
|
}
|
|
|
|
private final void checkVersion() {
|
|
try {
|
|
Version version = new Version(this.module.getVendorVersion());
|
|
if (version.toString().length() == 0) {
|
|
this.err(lex.getText("vmodule.err.verRequired"));
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
this.err(lex.getText("vmodule.err.version", new Object[]{this.module.getVendorVersion()}));
|
|
}
|
|
}
|
|
|
|
public ValidateModule(BProgramModule bProgramModule) {
|
|
this.module = bProgramModule;
|
|
}
|
|
}
|
|
}
|
|
|