575 lines
19 KiB
Java
575 lines
19 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
package javax.baja.sys;
|
|
|
|
import com.tridium.dataRecovery.BDataRecoveryComponentRecorder;
|
|
import com.tridium.sys.metrics.Metrics;
|
|
import com.tridium.sys.schema.ComponentSlotMap;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.naming.UnresolvedException;
|
|
import javax.baja.security.BPassword;
|
|
import javax.baja.security.BPermissionsMap;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BStruct;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Knob;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.SlotCursor;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Topic;
|
|
import javax.baja.sys.Type;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BLink
|
|
extends BStruct {
|
|
public static final Property sourceOrd = BLink.newProperty(0, BOrd.NULL, BFacets.make("targetType", "baja:Component"));
|
|
public static final Property sourceSlotName = BLink.newProperty(0, "");
|
|
public static final Property targetSlotName = BLink.newProperty(0, "");
|
|
public static final Property enabled = BLink.newProperty(0, true);
|
|
private static final BIcon icon = BIcon.std("link.png");
|
|
public static final Type TYPE;
|
|
private static final Log log;
|
|
private static final Context SKIP_CRITICAL_CX;
|
|
private BComponent direct;
|
|
private BComponent indirect;
|
|
private Slot sourceSlot;
|
|
private Slot targetSlot;
|
|
private boolean active;
|
|
private Knob knob;
|
|
private boolean fatalFault;
|
|
static /* synthetic */ Class class$javax$baja$sys$BLink;
|
|
|
|
public final BOrd getSourceOrd() {
|
|
return (BOrd)this.get(sourceOrd);
|
|
}
|
|
|
|
public final void setSourceOrd(BOrd bOrd) {
|
|
this.set(sourceOrd, (BValue)bOrd, null);
|
|
}
|
|
|
|
public final String getSourceSlotName() {
|
|
return this.getString(sourceSlotName);
|
|
}
|
|
|
|
public final void setSourceSlotName(String string) {
|
|
this.setString(sourceSlotName, string, null);
|
|
}
|
|
|
|
public final String getTargetSlotName() {
|
|
return this.getString(targetSlotName);
|
|
}
|
|
|
|
public final void setTargetSlotName(String string) {
|
|
this.setString(targetSlotName, string, null);
|
|
}
|
|
|
|
public final boolean isEnabled() {
|
|
return this.getBoolean(enabled);
|
|
}
|
|
|
|
public final boolean getEnabled() {
|
|
return this.getBoolean(enabled);
|
|
}
|
|
|
|
public final void setEnabled(boolean bl) {
|
|
this.setBoolean(enabled, bl, null);
|
|
}
|
|
|
|
public final boolean isDirect() {
|
|
boolean bl = false;
|
|
if (this.direct != null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final boolean isIndirect() {
|
|
boolean bl = false;
|
|
if (this.direct == null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final BComponent getSourceComponent() {
|
|
if (this.direct != null) {
|
|
return this.direct;
|
|
}
|
|
if (!this.active) {
|
|
throw new UnresolvedException();
|
|
}
|
|
return this.indirect;
|
|
}
|
|
|
|
public final Slot getSourceSlot() {
|
|
if (this.direct != null) {
|
|
return this.sourceSlot;
|
|
}
|
|
if (!this.active) {
|
|
throw new UnresolvedException();
|
|
}
|
|
return this.sourceSlot;
|
|
}
|
|
|
|
public final BComponent getTargetComponent() {
|
|
return (BComponent)this.getParent();
|
|
}
|
|
|
|
public final Slot getTargetSlot() {
|
|
if (this.direct != null) {
|
|
return this.targetSlot;
|
|
}
|
|
if (!this.active) {
|
|
throw new UnresolvedException();
|
|
}
|
|
return this.targetSlot;
|
|
}
|
|
|
|
public final boolean isActive() {
|
|
return this.active;
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Unable to fully structure code
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void activate() {
|
|
block15: {
|
|
block14: {
|
|
if (BLink.runningInStation() && !Metrics.incrementLink()) {
|
|
this.fatalFault = true;
|
|
BLink.log.error("Exceeded link limit for globalCapacity");
|
|
}
|
|
if (this.active) {
|
|
return;
|
|
}
|
|
var1_1 = (BComponent)this.getParent();
|
|
if (var1_1 == null) {
|
|
throw new IllegalStateException("not mounted in component");
|
|
}
|
|
var2_2 = this.isDirect() != false ? this.direct : this.resolve();
|
|
var3_3 = var1_1.getSlot(this.getTargetSlotName());
|
|
if (var3_3 != null && var3_3.isProperty() && ((var4_4 = var3_3.asProperty()).getType().is(BPassword.TYPE) || var4_4.getType().is(BPermissionsMap.TYPE))) {
|
|
BLink.log.warning("Link target can not be a BPassword or BPermissionsMap");
|
|
if (this.getParent().isComponent() == false) return;
|
|
this.getParent().asComponent().remove(this.getPropertyInParent());
|
|
return;
|
|
}
|
|
var4_4 = var2_2.getSlot(this.getSourceSlotName());
|
|
if (var4_4 != null && var4_4.isProperty() && ((var5_5 = var4_4.asProperty()).getType().is(BPassword.TYPE) || var5_5.getType().is(BPermissionsMap.TYPE))) {
|
|
BLink.log.warning("Link source can not be a BPassword or BPermissionsMap");
|
|
if (this.getParent().isComponent() == false) return;
|
|
this.getParent().asComponent().remove(this.getPropertyInParent());
|
|
return;
|
|
}
|
|
try {
|
|
try {
|
|
this.active = true;
|
|
this.knob = ((ComponentSlotMap)var2_2.getSlotMap()).installKnob(this);
|
|
}
|
|
catch (RuntimeException var8_7) {
|
|
this.active = false;
|
|
throw var8_7;
|
|
}
|
|
}
|
|
catch (Throwable var5_6) {
|
|
var6_8 = null;
|
|
if (!this.active) {
|
|
this.recomputeSlotFlags(var1_1, var3_3);
|
|
throw var5_6;
|
|
}
|
|
try {
|
|
var1_1.setFlags(var3_3, var1_1.getFlags(var3_3) | 32768, BLink.SKIP_CRITICAL_CX);
|
|
throw var5_6;
|
|
}
|
|
catch (Exception var7_10) {
|
|
var7_10.printStackTrace();
|
|
throw var5_6;
|
|
}
|
|
}
|
|
{
|
|
var6_9 = null;
|
|
if (!this.active) break block14;
|
|
}
|
|
** try [egrp 2[TRYBLOCK] [2 : 326->345)] {
|
|
lbl45:
|
|
// 1 sources
|
|
|
|
var1_1.setFlags(var3_3, var1_1.getFlags(var3_3) | 32768, BLink.SKIP_CRITICAL_CX);
|
|
lbl47:
|
|
// 1 sources
|
|
|
|
catch (Exception var7_11) {
|
|
var7_11.printStackTrace();
|
|
}
|
|
break block15;
|
|
}
|
|
this.recomputeSlotFlags(var1_1, var3_3);
|
|
}
|
|
if (var4_4.isProperty() == false) return;
|
|
if (var3_3.isProperty() == false) return;
|
|
this.propagate(null);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void deactivate() {
|
|
if (!this.active) {
|
|
return;
|
|
}
|
|
BComponent bComponent = null;
|
|
Slot slot = null;
|
|
try {
|
|
try {
|
|
slot = this.getTargetSlot();
|
|
}
|
|
catch (Exception exception) {}
|
|
if (this.active) {
|
|
((ComponentSlotMap)this.getSourceComponent().getSlotMap()).uninstallKnob(this);
|
|
bComponent = this.getTargetComponent();
|
|
((ComponentSlotMap)bComponent.getSlotMap()).deactivating(this);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var4_4 = null;
|
|
this.active = false;
|
|
this.knob = null;
|
|
if (this.indirect != null) {
|
|
this.indirect = null;
|
|
this.sourceSlot = null;
|
|
this.targetSlot = null;
|
|
}
|
|
this.recomputeSlotFlags(bComponent, slot);
|
|
throw throwable;
|
|
}
|
|
{
|
|
Object var4_5 = null;
|
|
this.active = false;
|
|
this.knob = null;
|
|
if (this.indirect != null) {
|
|
this.indirect = null;
|
|
this.sourceSlot = null;
|
|
this.targetSlot = null;
|
|
}
|
|
this.recomputeSlotFlags(bComponent, slot);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private final void recomputeSlotFlags(BComponent bComponent, Slot slot) {
|
|
if (bComponent == null) {
|
|
return;
|
|
}
|
|
try {
|
|
if (slot != null) {
|
|
this.computeLinkTargetFlag(bComponent, slot);
|
|
} else {
|
|
SlotCursor slotCursor = bComponent.getSlots();
|
|
while (slotCursor.nextObject()) {
|
|
this.computeLinkTargetFlag(bComponent, slotCursor.slot());
|
|
}
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private final void computeLinkTargetFlag(BComponent bComponent, Slot slot) {
|
|
try {
|
|
int n = bComponent.getFlags(slot);
|
|
BLink[] bLinkArray = bComponent.getLinks(slot);
|
|
int n2 = 0;
|
|
if (bLinkArray != null) {
|
|
n2 = bLinkArray.length;
|
|
}
|
|
int n3 = n2;
|
|
boolean bl = false;
|
|
int n4 = 0;
|
|
while (n4 < n3) {
|
|
if (bLinkArray[n4].isActive()) {
|
|
bl = true;
|
|
break;
|
|
}
|
|
++n4;
|
|
}
|
|
if (bl) {
|
|
bComponent.setFlags(slot, n | 0x8000, SKIP_CRITICAL_CX);
|
|
} else {
|
|
bComponent.setFlags(slot, n & 0xFFFF7FFF, SKIP_CRITICAL_CX);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public Knob getKnob() {
|
|
if (!this.active) {
|
|
throw new UnresolvedException();
|
|
}
|
|
return this.knob;
|
|
}
|
|
|
|
private final BComponent resolve() {
|
|
this.indirect = null;
|
|
try {
|
|
BObject bObject = this.getSourceOrd().resolve(this.getParentComponent()).get();
|
|
if (!(bObject instanceof BComponent)) {
|
|
throw new BajaRuntimeException("Source ord must resolve to a component");
|
|
}
|
|
this.indirect = (BComponent)bObject;
|
|
}
|
|
catch (UnresolvedException unresolvedException) {
|
|
throw new UnresolvedException("Cannot resolve source component");
|
|
}
|
|
this.sourceSlot = this.indirect.getSlot(this.getSourceSlotName());
|
|
if (this.sourceSlot == null) {
|
|
throw new UnresolvedException("Source slot does not exist");
|
|
}
|
|
this.targetSlot = this.getParent().getSlot(this.getTargetSlotName());
|
|
if (this.targetSlot == null) {
|
|
throw new UnresolvedException("Target slot does not exist");
|
|
}
|
|
return this.indirect;
|
|
}
|
|
|
|
public String toString(Context context) {
|
|
Object object;
|
|
String string = "null";
|
|
BComponent bComponent = this.getTargetComponent();
|
|
if (bComponent != null) {
|
|
object = bComponent.getSlotPath();
|
|
string = object == null ? bComponent.toString() : ((SlotPath)object).toString();
|
|
}
|
|
object = this.direct != null ? "Direct: " + this.direct.toDebugString() : "Indirect: " + this.getSourceOrd();
|
|
return (String)object + '.' + this.getSourceSlotName() + " -> " + string + '.' + this.getTargetSlotName();
|
|
}
|
|
|
|
public void propagate(BValue bValue) {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
if (this.getTargetComponent() == this.getSourceComponent() && this.getTargetSlot() == this.getSourceSlot()) {
|
|
System.out.println("WARNING: Infinite link: " + this);
|
|
return;
|
|
}
|
|
if (this.sourceSlot.isAction()) {
|
|
if (this.targetSlot.isAction()) {
|
|
this.propagateActionToAction(bValue);
|
|
return;
|
|
}
|
|
if (this.targetSlot.isTopic()) {
|
|
this.propagateActionToTopic(bValue);
|
|
return;
|
|
}
|
|
} else if (this.sourceSlot.isTopic()) {
|
|
if (this.targetSlot.isAction()) {
|
|
this.propagateTopicToAction(bValue);
|
|
return;
|
|
}
|
|
if (this.targetSlot.isTopic()) {
|
|
this.propagateTopicToTopic(bValue);
|
|
return;
|
|
}
|
|
} else if (this.sourceSlot.isProperty()) {
|
|
if (this.targetSlot.isAction()) {
|
|
this.propagatePropertyToAction();
|
|
return;
|
|
}
|
|
if (this.targetSlot.isProperty()) {
|
|
this.propagatePropertyToProperty();
|
|
return;
|
|
}
|
|
}
|
|
throw new IllegalStateException("Invalid link config");
|
|
}
|
|
|
|
public void propagatePropertyToAction() {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
Action action = this.getTargetSlot().asAction();
|
|
BValue bValue = null;
|
|
if (action.getParameterType() != null) {
|
|
bValue = this.getSourceComponent().get(this.getSourceSlot().asProperty());
|
|
}
|
|
this.getTargetComponent().invoke(action, bValue);
|
|
}
|
|
|
|
public void propagatePropertyToProperty() {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
BComponent bComponent = this.getSourceComponent();
|
|
BComponent bComponent2 = this.getTargetComponent();
|
|
Property property = this.sourceSlot.asProperty();
|
|
Property property2 = this.targetSlot.asProperty();
|
|
switch (property.getTypeAccess()) {
|
|
case 0: {
|
|
bComponent2.setBoolean(property2, bComponent.getBoolean(property), null);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComponent2.setInt(property2, bComponent.getInt(property), null);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComponent2.setLong(property2, bComponent.getLong(property), null);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComponent2.setFloat(property2, bComponent.getFloat(property), null);
|
|
break;
|
|
}
|
|
case 5: {
|
|
bComponent2.setDouble(property2, bComponent.getDouble(property), null);
|
|
break;
|
|
}
|
|
case 6: {
|
|
bComponent2.setString(property2, bComponent.getString(property), null);
|
|
break;
|
|
}
|
|
case 7: {
|
|
BValue bValue = bComponent.get(property);
|
|
if (bValue.isSimple()) {
|
|
bComponent2.set(property2, bValue, null);
|
|
break;
|
|
}
|
|
bComponent2.get(property2).asComplex().copyFrom(bValue.asComplex());
|
|
break;
|
|
}
|
|
default: {
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void propagateActionToAction(BValue bValue) {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
Action action = this.getTargetSlot().asAction();
|
|
this.getTargetComponent().invoke(action, bValue);
|
|
}
|
|
|
|
public void propagateActionToTopic(BValue bValue) {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
Topic topic = this.getTargetSlot().asTopic();
|
|
this.getTargetComponent().fire(topic, bValue);
|
|
}
|
|
|
|
public void propagateTopicToAction(BValue bValue) {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
Action action = this.getTargetSlot().asAction();
|
|
BValue bValue2 = null;
|
|
if (action.getParameterType() != null) {
|
|
bValue2 = bValue;
|
|
}
|
|
this.getTargetComponent().invoke(action, bValue2);
|
|
}
|
|
|
|
public void propagateTopicToTopic(BValue bValue) {
|
|
if (this.fatalFault) {
|
|
return;
|
|
}
|
|
Topic topic = this.getTargetSlot().asTopic();
|
|
this.getTargetComponent().fire(topic, bValue);
|
|
}
|
|
|
|
public boolean isFatalFault() {
|
|
return this.fatalFault;
|
|
}
|
|
|
|
private static final boolean runningInStation() {
|
|
boolean bl = false;
|
|
if (Sys.getStation() != null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
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());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.fatalFault = false;
|
|
}
|
|
|
|
public BLink(BOrd bOrd, String string, String string2, boolean bl) {
|
|
this.this();
|
|
this.setSourceOrd(bOrd);
|
|
this.setSourceSlotName(string);
|
|
this.setTargetSlotName(string2);
|
|
this.setEnabled(bl);
|
|
}
|
|
|
|
public BLink(BComponent bComponent, Slot slot, Slot slot2) {
|
|
this.this();
|
|
if (bComponent.getSlot(slot.getName()) == null) {
|
|
log.warning("No Such Slot: " + bComponent.getType() + '.' + slot.getName());
|
|
}
|
|
this.direct = bComponent;
|
|
this.setSourceSlotName(slot.getName());
|
|
this.setTargetSlotName(slot2.getName());
|
|
this.sourceSlot = slot;
|
|
this.targetSlot = slot2;
|
|
}
|
|
|
|
public BLink() {
|
|
this.this();
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$javax$baja$sys$BLink;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$sys$BLink = BLink.class("[Ljavax.baja.sys.BLink;", false);
|
|
}
|
|
TYPE = Sys.loadType(clazz);
|
|
log = Log.getLog("sys.link");
|
|
SKIP_CRITICAL_CX = BDataRecoveryComponentRecorder.SKIP_CRITICAL_CX;
|
|
}
|
|
}
|
|
|