2307 lines
88 KiB
Java
2307 lines
88 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.nre.util.Array
|
|
*/
|
|
package com.tridium.sys.schema;
|
|
|
|
import com.tridium.dataRecovery.BDataRecoveryComponentEvent;
|
|
import com.tridium.dataRecovery.BDataRecoveryComponentRecorder;
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.engine.EngineUtil;
|
|
import com.tridium.sys.engine.LocalKnob;
|
|
import com.tridium.sys.engine.NKnob;
|
|
import com.tridium.sys.engine.SlotKnobs;
|
|
import com.tridium.sys.schema.ActionCursor;
|
|
import com.tridium.sys.schema.ComplexSlotMap;
|
|
import com.tridium.sys.schema.ComplexType;
|
|
import com.tridium.sys.schema.DynamicTable;
|
|
import com.tridium.sys.schema.NAction;
|
|
import com.tridium.sys.schema.NActionProperty;
|
|
import com.tridium.sys.schema.NProperty;
|
|
import com.tridium.sys.schema.NSlot;
|
|
import com.tridium.sys.schema.NTopic;
|
|
import com.tridium.sys.schema.NTopicProperty;
|
|
import com.tridium.sys.schema.PropertyCursor;
|
|
import com.tridium.sys.schema.SlotsCursor;
|
|
import com.tridium.sys.schema.TopicCursor;
|
|
import com.tridium.sys.schema.UnhandledSlotException;
|
|
import com.tridium.sys.transfer.TransferListener;
|
|
import com.tridium.sys.transfer.TransferStrategy;
|
|
import com.tridium.util.ObjectUtil;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import javax.baja.category.BCategoryMask;
|
|
import javax.baja.category.BCategoryService;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.BasicQuery;
|
|
import javax.baja.naming.OrdQuery;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.nav.BINavNode;
|
|
import javax.baja.nav.BNavRoot;
|
|
import javax.baja.nav.NavEvent;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.registry.TypeInfo;
|
|
import javax.baja.security.BIProtected;
|
|
import javax.baja.security.BPassword;
|
|
import javax.baja.security.BPermissions;
|
|
import javax.baja.security.BPermissionsMap;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.space.TrapCallbacks;
|
|
import javax.baja.sync.Transaction;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.ActionInvokeException;
|
|
import javax.baja.sys.AlreadyParentedException;
|
|
import javax.baja.sys.BAction;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BComponentEvent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BIService;
|
|
import javax.baja.sys.BLink;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BString;
|
|
import javax.baja.sys.BTopic;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.CopyHints;
|
|
import javax.baja.sys.DuplicateSlotException;
|
|
import javax.baja.sys.Flags;
|
|
import javax.baja.sys.FrozenSlotException;
|
|
import javax.baja.sys.IllegalChildException;
|
|
import javax.baja.sys.IllegalParentException;
|
|
import javax.baja.sys.Knob;
|
|
import javax.baja.sys.NoSuchSlotException;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.SlotCursor;
|
|
import javax.baja.sys.Subscriber;
|
|
import javax.baja.sys.Topic;
|
|
import javax.baja.user.BUser;
|
|
import javax.baja.user.BUserService;
|
|
import javax.baja.util.BTypeSpec;
|
|
import javax.baja.util.BUnrestrictedFolder;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public abstract class ComponentSlotMap
|
|
extends ComplexSlotMap
|
|
implements ObjectUtil.NameContainer {
|
|
static final int CHANGED = 0;
|
|
static final int ADDED = 1;
|
|
static final int REMOVED = 2;
|
|
static final int RENAMED = 3;
|
|
static final int REORDERED = 4;
|
|
static final int PARENTED = 5;
|
|
static final int UNPARENTED = 6;
|
|
static final int ACTION_INVOKED = 7;
|
|
static final int TOPIC_FIRED = 8;
|
|
static final int FLAGS_CHANGED = 9;
|
|
static final int FACETS_CHANGED = 10;
|
|
static final int RECATEGORIZED = 11;
|
|
static final int KNOB_ADDED = 12;
|
|
static final int KNOB_REMOVED = 13;
|
|
static final int STARTED = 14;
|
|
static final int STOPPED = 15;
|
|
static final int[] COMPONENT_EVENT;
|
|
static final int[] COMPONENT_CHILD_EVENT;
|
|
static final int INITIALIZED = 1;
|
|
static final int MOUNTED = 2;
|
|
static final int RUNNING = 4;
|
|
static final int BROKER_PROPS_LOADED = 8;
|
|
static final int PENDING_MOVE = 16;
|
|
static final int PERMANENT_SUBSCRIBE = 32;
|
|
static final int IS_WIDGET = 64;
|
|
public static final boolean REQUIRE_SUPER_USER_PERMISSION;
|
|
static TypeInfo PROG_OBJ_TYPE_INFO;
|
|
static TypeInfo PROG_CODE_TYPE_INFO;
|
|
public static final String SWIZZLE_PREFIX = "copy-";
|
|
private static final Subscriber[] noSubscribers;
|
|
private static final NKnob[] noKnobs;
|
|
private int[] frozenFlags;
|
|
private DynamicTable table;
|
|
private SlotKnobs[] frozenKnobs;
|
|
private Subscriber[] subscribers;
|
|
private int knobCount;
|
|
private int mask;
|
|
private String handle;
|
|
private BComponentSpace space;
|
|
private BPermissions cachedPermissions;
|
|
private BCategoryMask cat;
|
|
private BCategoryMask catDeepOr;
|
|
|
|
public final void init(ComplexType complexType, BComplex bComplex) {
|
|
super.init(complexType, bComplex);
|
|
this.setInitialized(true);
|
|
int[] nArray = complexType.defaultFlags;
|
|
int[] nArray2 = new int[nArray.length];
|
|
System.arraycopy(nArray, 0, nArray2, 0, nArray2.length);
|
|
this.frozenFlags = nArray2;
|
|
if (bComplex.fw(301) != null) {
|
|
this.setIsWidget(true);
|
|
}
|
|
}
|
|
|
|
public final String getName() {
|
|
if (this.propertyInParent != null) {
|
|
return this.propertyInParent.getName();
|
|
}
|
|
return (String)this.instance.fw(24);
|
|
}
|
|
|
|
public final String getDisplayName(Context context) {
|
|
if (this.propertyInParent != null) {
|
|
return super.getDisplayName(context);
|
|
}
|
|
if (this.space != null && this.space.getRootComponent() == this.instance) {
|
|
return this.space.getNavDisplayName(context);
|
|
}
|
|
return (String)this.instance.fw(25, context, null, null, null);
|
|
}
|
|
|
|
public final Object getHandle() {
|
|
return this.handle;
|
|
}
|
|
|
|
public final void setHandle(Object object) {
|
|
this.handle = (String)object;
|
|
}
|
|
|
|
public final SlotPath getSlotPath() {
|
|
if (this.space == null) {
|
|
return null;
|
|
}
|
|
ArrayList<String> arrayList = new ArrayList<String>();
|
|
BComponent bComponent = this.instance.asComponent();
|
|
BComponent bComponent2 = this.space.getRootComponent();
|
|
while (bComponent != null && bComponent != bComponent2) {
|
|
arrayList.add(bComponent.getName());
|
|
bComponent = (BComponent)bComponent.getParent();
|
|
}
|
|
String[] stringArray = new String[arrayList.size()];
|
|
int n = arrayList.size();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
stringArray[n - n2 - 1] = (String)arrayList.get(n2);
|
|
++n2;
|
|
}
|
|
return new SlotPath("slot", stringArray);
|
|
}
|
|
|
|
SlotPath getAuditSlotPath(Context context) {
|
|
SlotPath slotPath = this.instance.asComponent().getSlotPath();
|
|
if (slotPath == null && context != null) {
|
|
slotPath = ComplexSlotMap.getSlotPathFromContext(context);
|
|
}
|
|
return slotPath;
|
|
}
|
|
|
|
public final boolean equivalent(ComplexSlotMap complexSlotMap) {
|
|
if (!super.equivalent(complexSlotMap)) {
|
|
return false;
|
|
}
|
|
ComponentSlotMap componentSlotMap = (ComponentSlotMap)complexSlotMap;
|
|
if (this.table == null || this.table.count == 0) {
|
|
boolean bl = false;
|
|
if (componentSlotMap.table == null || componentSlotMap.table.count == 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
return this.table.equivalent(componentSlotMap.table);
|
|
}
|
|
|
|
public final BComplex newCopy(CopyHints copyHints, int n) {
|
|
BValue[] bValueArray;
|
|
if (copyHints instanceof TransferListener) {
|
|
bValueArray = (TransferListener)((Object)copyHints);
|
|
bValueArray.updateStatus("Copying \"" + TransferStrategy.toString(this.instance) + "\"...");
|
|
}
|
|
if (this.space != null) {
|
|
bValueArray = new BValue[]{this.instance};
|
|
bValueArray = this.space.getLoadCallbacks().newCopy(bValueArray, copyHints);
|
|
if (bValueArray != null && bValueArray[0] != null) {
|
|
return (BComplex)bValueArray[0];
|
|
}
|
|
}
|
|
bValueArray = (BComponent)super.newCopy(copyHints, n);
|
|
Context context = Context.copying;
|
|
boolean bl = false;
|
|
if (copyHints.cx != null && (copyHints.cx.getUser() != null || copyHints.cx.getFacets() != null && copyHints.cx.getFacets().gets("username", null) != null)) {
|
|
bl = true;
|
|
}
|
|
boolean bl2 = bl;
|
|
ComponentSlotMap componentSlotMap = ComponentSlotMap.getComponentSlotMap((BObject)bValueArray);
|
|
if (copyHints.swizzleHandles && this.handle != null) {
|
|
componentSlotMap.handle = ComponentSlotMap.swizzle(this.handle, n);
|
|
}
|
|
componentSlotMap.frozenFlags = new int[this.frozenFlags.length];
|
|
System.arraycopy(this.frozenFlags, 0, componentSlotMap.frozenFlags, 0, this.frozenFlags.length);
|
|
componentSlotMap.cat = this.cat;
|
|
if (this.table != null) {
|
|
int n2 = 0;
|
|
while (n2 < this.table.count) {
|
|
NProperty nProperty = this.table.slots[n2];
|
|
String string = nProperty.name;
|
|
BValue bValue = nProperty.value;
|
|
if (!(bValue instanceof BLink && ((BLink)bValue).isDirect() || bValueArray.getSlot(string) != null || copyHints.defaultOnClone && (nProperty.flags & 0x2000) == 8192 || bl2 && nProperty.getType().equals(BPassword.TYPE))) {
|
|
if (bValue.isComponent() && copyHints.cx != null) {
|
|
if (((BComponent)bValue).getPermissions(copyHints.cx).hasOperatorRead()) {
|
|
bValue = ComponentSlotMap.newCopy(bValue, copyHints, n);
|
|
bValueArray.add(string, bValue, nProperty.flags, nProperty.facets, context);
|
|
}
|
|
} else {
|
|
bValue = ComponentSlotMap.newCopy(bValue, copyHints, n);
|
|
bValueArray.add(string, bValue, nProperty.flags, nProperty.facets, context);
|
|
}
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
return bValueArray;
|
|
}
|
|
|
|
BValue getOverride(Property property) {
|
|
if (this.isWidget()) {
|
|
return (BValue)this.instance.fw(19, property, null, null, null);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final int getSlotCount() {
|
|
if (this.table == null) {
|
|
return this.getType().slots.length;
|
|
}
|
|
return this.getType().slots.length + this.table.count;
|
|
}
|
|
|
|
public final Slot getSlot(String string) {
|
|
Slot slot = (Slot)this.getType().byName.get(string);
|
|
if (slot != null) {
|
|
return slot;
|
|
}
|
|
if (this.table != null) {
|
|
return this.table.get(string);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final Slot[] getSlotsArray() {
|
|
if (this.table == null) {
|
|
return super.getSlotsArray();
|
|
}
|
|
NSlot[] nSlotArray = this.getType().slots;
|
|
Object[] objectArray = new Slot[nSlotArray.length + this.table.count];
|
|
System.arraycopy(nSlotArray, 0, objectArray, 0, nSlotArray.length);
|
|
this.table.copyInto(objectArray, nSlotArray.length);
|
|
return objectArray;
|
|
}
|
|
|
|
public final Property[] getPropertiesArray() {
|
|
if (this.table == null) {
|
|
return super.getPropertiesArray();
|
|
}
|
|
NProperty[] nPropertyArray = this.getType().properties;
|
|
Object[] objectArray = new Property[nPropertyArray.length + this.table.count];
|
|
System.arraycopy(nPropertyArray, 0, objectArray, 0, nPropertyArray.length);
|
|
this.table.copyInto(objectArray, nPropertyArray.length);
|
|
return objectArray;
|
|
}
|
|
|
|
public Property[] getFrozenPropertiesArray() {
|
|
return super.getPropertiesArray();
|
|
}
|
|
|
|
public Property[] getDynamicPropertiesArray() {
|
|
if (this.table == null) {
|
|
return super.getDynamicPropertiesArray();
|
|
}
|
|
Object[] objectArray = new Property[this.table.count];
|
|
this.table.copyInto(objectArray, 0);
|
|
return objectArray;
|
|
}
|
|
|
|
public final Action[] getActionsArray() {
|
|
if (this.table == null) {
|
|
return super.getActionsArray();
|
|
}
|
|
NAction[] nActionArray = this.getType().actions;
|
|
Action[] actionArray = new Action[nActionArray.length + this.table.count];
|
|
int n = nActionArray.length;
|
|
System.arraycopy(nActionArray, 0, actionArray, 0, n);
|
|
int n2 = 0;
|
|
while (n2 < this.table.count) {
|
|
if (this.table.slots[n2].isAction()) {
|
|
actionArray[n++] = this.table.slots[n2].asAction();
|
|
}
|
|
++n2;
|
|
}
|
|
Action[] actionArray2 = new Action[n];
|
|
System.arraycopy(actionArray, 0, actionArray2, 0, n);
|
|
return actionArray2;
|
|
}
|
|
|
|
public final Topic[] getTopicsArray() {
|
|
if (this.table == null) {
|
|
return super.getTopicsArray();
|
|
}
|
|
NTopic[] nTopicArray = this.getType().topics;
|
|
Topic[] topicArray = new Topic[nTopicArray.length + this.table.count];
|
|
int n = nTopicArray.length;
|
|
System.arraycopy(nTopicArray, 0, topicArray, 0, n);
|
|
int n2 = 0;
|
|
while (n2 < this.table.count) {
|
|
if (this.table.slots[n2].isTopic()) {
|
|
topicArray[n++] = this.table.slots[n2].asTopic();
|
|
}
|
|
++n2;
|
|
}
|
|
Topic[] topicArray2 = new Topic[n];
|
|
System.arraycopy(topicArray, 0, topicArray2, 0, n);
|
|
return topicArray2;
|
|
}
|
|
|
|
public final SlotCursor getSlots() {
|
|
return new SlotsCursor(this.instance, this.getType().slots, this.table);
|
|
}
|
|
|
|
public final SlotCursor getProperties() {
|
|
return new PropertyCursor(this.instance, this.getType().properties, this.table);
|
|
}
|
|
|
|
public final SlotCursor getActions() {
|
|
return new ActionCursor(this.instance, this.getType().actions, this.table);
|
|
}
|
|
|
|
public final SlotCursor getTopics() {
|
|
return new TopicCursor(this.instance, this.getType().topics, this.table);
|
|
}
|
|
|
|
public int getFlags(Slot slot) {
|
|
NSlot nSlot = (NSlot)slot;
|
|
try {
|
|
if (nSlot.isFrozen) {
|
|
return this.frozenFlags[nSlot.index];
|
|
}
|
|
return nSlot.flags;
|
|
}
|
|
catch (RuntimeException runtimeException) {
|
|
System.out.println("ComponentSlotMap.getFlags: " + nSlot);
|
|
System.out.println(" instance.type " + this.getType());
|
|
System.out.println(" slot.type: " + nSlot.getDeclaringType());
|
|
System.out.println(" slot.index: " + nSlot.index);
|
|
System.out.println(" slot.isFrozen: " + nSlot.isFrozen);
|
|
System.out.println(" type.slots.length: " + this.getType().slots.length);
|
|
System.out.println(" type.defaultFlags.length: " + this.getType().defaultFlags.length);
|
|
runtimeException.printStackTrace();
|
|
throw runtimeException;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void setFlags(Slot slot, int n, Context context) {
|
|
String string;
|
|
BUser bUser;
|
|
NSlot nSlot;
|
|
block13: {
|
|
BObject bObject;
|
|
nSlot = (NSlot)slot;
|
|
if (this.getFlags(nSlot) == n) {
|
|
return;
|
|
}
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
bComponent.checkSetFlags(slot, n, context);
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).setFlags(bComponent, nSlot, n, null);
|
|
return;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.setFlags(bComponent, nSlot, n, context);
|
|
return;
|
|
}
|
|
bUser = null;
|
|
string = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
if (nSlot instanceof NProperty && (bObject = this.get((NProperty)nSlot)) instanceof BIProtected) {
|
|
bUser.check((BIProtected)((Object)bObject), BPermissions.adminWrite);
|
|
}
|
|
string = Flags.encodeToString(this.getFlags(slot));
|
|
}
|
|
if ((bObject = this.findRecoveryData(6, nSlot, n, context)) != null) {
|
|
bObject.record(BDataRecoveryComponentEvent.makeFlagsChangeEvent(bComponent, nSlot.getName(), n), context);
|
|
}
|
|
BComponent bComponent2 = bComponent;
|
|
synchronized (bComponent2) {
|
|
block12: {
|
|
if (!nSlot.isFrozen) break block12;
|
|
if (this.frozenFlags[nSlot.index] == n) {
|
|
return;
|
|
}
|
|
this.frozenFlags[nSlot.index] = n;
|
|
break block13;
|
|
}
|
|
if (nSlot.flags == n) {
|
|
return;
|
|
}
|
|
nSlot.flags = n;
|
|
}
|
|
}
|
|
this.fireComponentEvent(9, nSlot, null, null, context);
|
|
if (bUser != null) {
|
|
String string2 = Flags.encodeToString(n);
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Flags Changed", nSlot.name, string, string2);
|
|
}
|
|
}
|
|
|
|
public final BComponentSpace getSpace() {
|
|
return this.space;
|
|
}
|
|
|
|
public final TrapCallbacks getSpaceTrap() {
|
|
if (this.space == null) {
|
|
return null;
|
|
}
|
|
return this.space.getTrapCallbacks();
|
|
}
|
|
|
|
public void loadSlots() {
|
|
if (this.space == null) {
|
|
return;
|
|
}
|
|
if (this.isBrokerPropsLoaded()) {
|
|
return;
|
|
}
|
|
this.space.getLoadCallbacks().loadSlots((BComponent)this.instance);
|
|
this.setBrokerPropsLoaded(true);
|
|
}
|
|
|
|
public final boolean isSubscribed() {
|
|
if (this.isPermanentlySubscribed() || this.knobCount > 0 && this.isRunning()) {
|
|
return true;
|
|
}
|
|
boolean bl = false;
|
|
int n = 0;
|
|
while (n < this.subscribers.length) {
|
|
Subscriber subscriber = null;
|
|
try {
|
|
subscriber = this.subscribers[n];
|
|
}
|
|
catch (Exception exception) {}
|
|
if (!(subscriber instanceof PendingSubscriber)) {
|
|
bl = true;
|
|
break;
|
|
}
|
|
++n;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final boolean isPermanentlySubscribed() {
|
|
boolean bl = false;
|
|
if ((this.mask & 0x20) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void setPermanentlySubscribed(boolean bl) {
|
|
if (bl == this.isPermanentlySubscribed()) {
|
|
return;
|
|
}
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
boolean bl2;
|
|
block8: {
|
|
block7: {
|
|
bl2 = this.isSubscribed();
|
|
if (!bl) break block7;
|
|
this.mask |= 0x20;
|
|
break block8;
|
|
}
|
|
this.mask &= 0xFFFFFFDF;
|
|
}
|
|
boolean bl3 = this.isSubscribed();
|
|
if (bl2 != bl3) {
|
|
if (bl3) {
|
|
this.subscribe(true);
|
|
} else {
|
|
this.unsubscribe(true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public Subscriber[] getSubscribers() {
|
|
int n = this.subscribers.length;
|
|
Array array = new Array((Object[])new Subscriber[n], 0);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
if (!(this.subscribers[n2] instanceof PendingSubscriber)) {
|
|
array.add((Object)this.subscribers[n2]);
|
|
}
|
|
++n2;
|
|
}
|
|
return (Subscriber[])array.trim();
|
|
}
|
|
|
|
public boolean isSubscribed(int n) {
|
|
if (n == -1) {
|
|
return false;
|
|
}
|
|
int n2 = 0;
|
|
while (n2 < this.subscribers.length) {
|
|
Subscriber subscriber = this.subscribers[n2];
|
|
if (subscriber instanceof PendingSubscriber) {
|
|
subscriber = ((PendingSubscriber)subscriber).subscriber;
|
|
}
|
|
if (subscriber.getMask().includes(n)) {
|
|
return true;
|
|
}
|
|
++n2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void subscribe(Subscriber subscriber) {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
boolean bl;
|
|
boolean bl2 = this.isSubscribed();
|
|
int n = this.subscribers.length;
|
|
boolean bl3 = true;
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
Subscriber subscriber2 = this.subscribers[n2];
|
|
if (subscriber2 instanceof PendingSubscriber && ((PendingSubscriber)subscriber2).subscriber == subscriber) {
|
|
this.subscribers[n2] = subscriber;
|
|
bl3 = false;
|
|
break;
|
|
}
|
|
++n2;
|
|
}
|
|
if (bl3) {
|
|
Subscriber[] subscriberArray = new Subscriber[this.subscribers.length + 1];
|
|
System.arraycopy(this.subscribers, 0, subscriberArray, 0, this.subscribers.length);
|
|
subscriberArray[this.subscribers.length] = subscriber;
|
|
this.subscribers = subscriberArray;
|
|
}
|
|
if (bl2 != (bl = this.isSubscribed())) {
|
|
this.subscribe(false);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void unsubscribe(Subscriber subscriber) {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
int n = this.isSubscribed();
|
|
int n2 = 0;
|
|
while (n2 < this.subscribers.length) {
|
|
if (this.subscribers[n2] == subscriber || this.subscribers[n2] instanceof PendingSubscriber && ((PendingSubscriber)this.subscribers[n2]).subscriber == subscriber) {
|
|
Subscriber[] subscriberArray = new Subscriber[this.subscribers.length - 1];
|
|
System.arraycopy(this.subscribers, 0, subscriberArray, 0, n2);
|
|
if (n2 < this.subscribers.length) {
|
|
System.arraycopy(this.subscribers, n2 + 1, subscriberArray, n2, this.subscribers.length - n2 - 1);
|
|
}
|
|
this.subscribers = subscriberArray;
|
|
break;
|
|
}
|
|
++n2;
|
|
}
|
|
n2 = this.isSubscribed() ? 1 : 0;
|
|
if (n != n2) {
|
|
this.unsubscribe(false);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void unsubscribeAll() {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
boolean bl = this.isSubscribed();
|
|
this.subscribers = noSubscribers;
|
|
boolean bl2 = this.isSubscribed();
|
|
if (bl != bl2) {
|
|
this.unsubscribe(true);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public final void subscribe(boolean bl) {
|
|
try {
|
|
if (bl && this.space != null) {
|
|
this.space.getSubscribeCallbacks().subscribe(new BComponent[]{(BComponent)this.instance}, 0);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
try {
|
|
this.instance.fw(17, null, null, null, null);
|
|
if (this.space == null || this.space.fireDirectCallbacks()) {
|
|
((BComponent)this.instance).subscribed();
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public final void unsubscribe(boolean bl) {
|
|
try {
|
|
if (bl && this.space != null) {
|
|
this.space.getSubscribeCallbacks().unsubscribe(new BComponent[]{(BComponent)this.instance});
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
try {
|
|
this.instance.fw(18, null, null, null, null);
|
|
if (this.space == null || this.space.fireDirectCallbacks()) {
|
|
((BComponent)this.instance).unsubscribed();
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public final BPermissions getCachedPermissions() {
|
|
return this.cachedPermissions;
|
|
}
|
|
|
|
public final void setCachedPermissions(BPermissions bPermissions) {
|
|
this.cachedPermissions = bPermissions;
|
|
}
|
|
|
|
final void modified(NProperty nProperty, Context context, BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder) {
|
|
SlotKnobs slotKnobs = this.getSlotKnobs(nProperty);
|
|
if (slotKnobs != null) {
|
|
slotKnobs.propagate(null);
|
|
}
|
|
this.fireComponentEvent(0, nProperty, null, null, context);
|
|
}
|
|
|
|
protected void fireComponentEvent(int n, Slot slot, Object object, String string, Context context) {
|
|
Object object2;
|
|
Subscriber[] subscriberArray;
|
|
BComponentEvent bComponentEvent;
|
|
int n2;
|
|
boolean bl;
|
|
BComponent bComponent;
|
|
block89: {
|
|
block88: {
|
|
if (!this.isInitialized()) {
|
|
return;
|
|
}
|
|
bComponent = this.instance.asComponent();
|
|
try {
|
|
switch (n) {
|
|
case 0: {
|
|
bComponent.fw(2, slot, context, null, null);
|
|
break;
|
|
}
|
|
case 1: {
|
|
bComponent.fw(3, slot, context, null, null);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComponent.fw(4, slot, object, context, null);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComponent.fw(5, slot, string, context, null);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComponent.fw(6, context, null, null, null);
|
|
break;
|
|
}
|
|
case 5: {
|
|
bComponent.fw(7, slot, object, context, null);
|
|
break;
|
|
}
|
|
case 6: {
|
|
bComponent.fw(8, slot, object, context, null);
|
|
break;
|
|
}
|
|
case 7: {
|
|
bComponent.fw(9, slot, object, context, null);
|
|
break;
|
|
}
|
|
case 8: {
|
|
bComponent.fw(10, slot, object, context, null);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
if (this.space == null || this.space.fireDirectCallbacks()) {
|
|
try {
|
|
switch (n) {
|
|
case 0: {
|
|
bComponent.changed((Property)slot, context);
|
|
break;
|
|
}
|
|
case 1: {
|
|
bComponent.added((Property)slot, context);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComponent.removed((Property)slot, (BValue)object, context);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComponent.renamed((Property)slot, string, context);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComponent.reordered(context);
|
|
break;
|
|
}
|
|
case 5: {
|
|
bComponent.childParented((Property)slot, (BValue)object, context);
|
|
break;
|
|
}
|
|
case 6: {
|
|
bComponent.childUnparented((Property)slot, (BValue)object, context);
|
|
break;
|
|
}
|
|
case 7: {
|
|
break;
|
|
}
|
|
case 8: {
|
|
break;
|
|
}
|
|
case 9: {
|
|
bComponent.flagsChanged(slot, context);
|
|
break;
|
|
}
|
|
case 10: {
|
|
bComponent.facetsChanged(slot, context);
|
|
break;
|
|
}
|
|
case 11: {
|
|
bComponent.recategorized(context);
|
|
break;
|
|
}
|
|
case 12: {
|
|
bComponent.knobAdded((Knob)object, context);
|
|
break;
|
|
}
|
|
case 13: {
|
|
bComponent.knobRemoved((Knob)object, context);
|
|
break;
|
|
}
|
|
case 14: {
|
|
break;
|
|
}
|
|
case 15: {
|
|
break;
|
|
}
|
|
default: {
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
if (this.space != null) {
|
|
try {
|
|
switch (n) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 9:
|
|
case 10:
|
|
case 11: {
|
|
this.space.modified(bComponent, context);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
BValue bValue = null;
|
|
switch (n) {
|
|
case 1: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bValue = (BValue)object;
|
|
break;
|
|
}
|
|
case 3: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
case 9: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
case 10: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bValue = null;
|
|
break;
|
|
}
|
|
case 12: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
case 13: {
|
|
if (!slot.isProperty()) break;
|
|
bValue = this.get((NProperty)slot);
|
|
break;
|
|
}
|
|
}
|
|
if (bValue == null || !bValue.isComponent()) break block88;
|
|
bl = ((ComponentSlotMap)bValue.asComponent().fw(1)).isSubscribed(COMPONENT_CHILD_EVENT[n]);
|
|
int n3 = 0;
|
|
if (this.getSpace() != null && this.getSpace().isSubscribed(bValue.getType(), COMPONENT_CHILD_EVENT[n])) {
|
|
n3 = 1;
|
|
}
|
|
if ((n2 = n3) == 0 && !bl) break block89;
|
|
bComponentEvent = null;
|
|
switch (n) {
|
|
case 1: {
|
|
bComponentEvent = new BComponentEvent(11, bValue.asComponent(), null, bComponent);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComponentEvent = new BComponentEvent(12, bValue.asComponent(), null, bComponent);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComponentEvent = new BComponentEvent(13, bValue.asComponent(), null, BString.make(string));
|
|
break;
|
|
}
|
|
case 9: {
|
|
bComponentEvent = new BComponentEvent(15, bValue.asComponent(), null, null);
|
|
break;
|
|
}
|
|
case 10: {
|
|
bComponentEvent = new BComponentEvent(16, bValue.asComponent(), null, (BFacets)object);
|
|
break;
|
|
}
|
|
}
|
|
subscriberArray = ((ComponentSlotMap)bValue.asComponent().fw((int)1)).subscribers;
|
|
int n4 = 0;
|
|
while (n4 < subscriberArray.length) {
|
|
try {
|
|
object2 = subscriberArray[n4];
|
|
if (object2 instanceof PendingSubscriber) {
|
|
object2 = ((PendingSubscriber)object2).subscriber;
|
|
}
|
|
((Subscriber)object2).event(bComponentEvent);
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
++n4;
|
|
}
|
|
if (n2 == 0) break block89;
|
|
this.getSpace().event(bComponentEvent);
|
|
break block89;
|
|
}
|
|
if (n == 4 && this.getSpace() != null) {
|
|
BComponent[] bComponentArray = bComponent.getChildComponents();
|
|
n2 = 0;
|
|
while (n2 < bComponentArray.length) {
|
|
if (this.getSpace().isSubscribed(bComponentArray[n2].getType(), 14)) {
|
|
this.getSpace().event(new BComponentEvent(14, bComponentArray[n2], null, bComponent));
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
}
|
|
bl = this.isSubscribed(COMPONENT_EVENT[n]);
|
|
int n5 = 0;
|
|
if (this.getSpace() != null && this.getSpace().isSubscribed(this.getType(), COMPONENT_EVENT[n])) {
|
|
n5 = 1;
|
|
}
|
|
if ((n2 = n5) != 0 || bl) {
|
|
bComponentEvent = null;
|
|
switch (n) {
|
|
case 0: {
|
|
subscriberArray = this.get((NProperty)slot);
|
|
bComponentEvent = new BComponentEvent(0, bComponent, slot, (BValue)subscriberArray);
|
|
break;
|
|
}
|
|
case 1: {
|
|
BValue bValue = this.get((NProperty)slot);
|
|
bComponentEvent = new BComponentEvent(1, bComponent, slot, bValue);
|
|
break;
|
|
}
|
|
case 2: {
|
|
object2 = (BValue)object;
|
|
bComponentEvent = new BComponentEvent(2, bComponent, slot, (BValue)object2);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComponentEvent = new BComponentEvent(3, bComponent, slot, BString.make(string));
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComponentEvent = new BComponentEvent(4, bComponent, null, null);
|
|
break;
|
|
}
|
|
case 8: {
|
|
bComponentEvent = new BComponentEvent(5, bComponent, slot, (BValue)object);
|
|
break;
|
|
}
|
|
case 9: {
|
|
bComponentEvent = new BComponentEvent(6, bComponent, slot, null);
|
|
break;
|
|
}
|
|
case 10: {
|
|
bComponentEvent = new BComponentEvent(7, bComponent, slot, (BFacets)object);
|
|
break;
|
|
}
|
|
case 11: {
|
|
bComponentEvent = new BComponentEvent(10, bComponent, null, (BCategoryMask)object);
|
|
break;
|
|
}
|
|
case 12: {
|
|
bComponentEvent = new BComponentEvent(8, bComponent, (Knob)object);
|
|
break;
|
|
}
|
|
case 13: {
|
|
bComponentEvent = new BComponentEvent(9, bComponent, (Knob)object);
|
|
break;
|
|
}
|
|
case 14: {
|
|
bComponentEvent = new BComponentEvent(19, bComponent, null, null);
|
|
break;
|
|
}
|
|
case 15: {
|
|
bComponentEvent = new BComponentEvent(20, bComponent, null, null);
|
|
break;
|
|
}
|
|
default: {
|
|
return;
|
|
}
|
|
}
|
|
int n6 = 0;
|
|
while (n6 < this.subscribers.length) {
|
|
try {
|
|
Subscriber subscriber = this.subscribers[n6];
|
|
if (subscriber instanceof PendingSubscriber) {
|
|
subscriber = ((PendingSubscriber)subscriber).subscriber;
|
|
}
|
|
subscriber.event(bComponentEvent);
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
++n6;
|
|
}
|
|
if (n2 != 0) {
|
|
this.getSpace().event(bComponentEvent);
|
|
}
|
|
}
|
|
}
|
|
|
|
BDataRecoveryComponentRecorder findRecoveryData(int n, Slot slot, Context context) {
|
|
boolean bl;
|
|
if (!this.isInitialized()) {
|
|
return null;
|
|
}
|
|
BComponent bComponent = this.instance.asComponent();
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder = Nre.serviceManager.getDataRecoveryComponentRecorder(this.space);
|
|
boolean bl2 = false;
|
|
if (bDataRecoveryComponentRecorder != null) {
|
|
bl2 = true;
|
|
}
|
|
if (bl = bl2) {
|
|
int n2 = slot != null ? this.getFlags(slot) : -1;
|
|
bl = bDataRecoveryComponentRecorder.isEventCritical(n, bComponent, slot, n2, context);
|
|
}
|
|
if (!bl) {
|
|
return null;
|
|
}
|
|
return bDataRecoveryComponentRecorder;
|
|
}
|
|
|
|
BDataRecoveryComponentRecorder findRecoveryData(int n, Slot slot, int n2, Context context) {
|
|
boolean bl;
|
|
if (!this.isInitialized()) {
|
|
return null;
|
|
}
|
|
BComponent bComponent = this.instance.asComponent();
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder = Nre.serviceManager.getDataRecoveryComponentRecorder(this.space);
|
|
boolean bl2 = false;
|
|
if (bDataRecoveryComponentRecorder != null) {
|
|
bl2 = true;
|
|
}
|
|
if (bl = bl2) {
|
|
bl = bDataRecoveryComponentRecorder.isEventCritical(n, bComponent, slot, n2, context);
|
|
}
|
|
if (!bl) {
|
|
return null;
|
|
}
|
|
return bDataRecoveryComponentRecorder;
|
|
}
|
|
|
|
public final SlotKnobs getSlotKnobs(NSlot nSlot) {
|
|
if (nSlot.isFrozen) {
|
|
if (this.frozenKnobs == null) {
|
|
return null;
|
|
}
|
|
return this.frozenKnobs[nSlot.index];
|
|
}
|
|
return nSlot.knobs;
|
|
}
|
|
|
|
public final Knob installKnob(BLink bLink) {
|
|
return this.installKnob(new LocalKnob(bLink), false);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final NKnob installKnob(NKnob nKnob, boolean bl) {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
NKnob nKnob2;
|
|
NSlot nSlot = (NSlot)nKnob.getSourceSlot();
|
|
if (nSlot == null) {
|
|
return nKnob;
|
|
}
|
|
SlotKnobs slotKnobs = this.getSlotKnobs(nSlot);
|
|
if (bl && slotKnobs != null && (nKnob2 = slotKnobs.get(nKnob.id)) != null) {
|
|
nKnob2.copyFrom(nKnob);
|
|
return nKnob2;
|
|
}
|
|
boolean bl2 = this.isSubscribed();
|
|
++this.knobCount;
|
|
boolean bl3 = this.isSubscribed();
|
|
if (nKnob.isLocal() && bl2 != bl3) {
|
|
this.subscribe(true);
|
|
}
|
|
if (slotKnobs != null) {
|
|
slotKnobs.add(nKnob);
|
|
} else {
|
|
slotKnobs = new SlotKnobs((BComponent)this.instance, nSlot, nKnob);
|
|
if (nSlot.isFrozen) {
|
|
if (this.frozenKnobs == null) {
|
|
this.frozenKnobs = new SlotKnobs[this.getType().slots.length];
|
|
}
|
|
this.frozenKnobs[nSlot.index] = slotKnobs;
|
|
} else {
|
|
nSlot.knobs = slotKnobs;
|
|
}
|
|
}
|
|
this.fireComponentEvent(12, nSlot, nKnob, null, null);
|
|
return nKnob;
|
|
}
|
|
}
|
|
|
|
public final void uninstallKnob(BLink bLink) {
|
|
this.uninstallKnob((NKnob)bLink.getKnob());
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void uninstallKnob(NKnob nKnob) {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
SlotKnobs slotKnobs;
|
|
NSlot nSlot;
|
|
boolean bl = this.isSubscribed();
|
|
--this.knobCount;
|
|
boolean bl2 = this.isSubscribed();
|
|
if (nKnob.isLocal() && bl != bl2) {
|
|
this.unsubscribe(true);
|
|
}
|
|
if ((nSlot = (NSlot)nKnob.getSourceSlot()) != null && (slotKnobs = this.getSlotKnobs(nSlot)) != null) {
|
|
slotKnobs.remove(nKnob);
|
|
}
|
|
this.fireComponentEvent(13, nSlot, nKnob, null, null);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Unable to fully structure code
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void mergeKnobs(List var1_1) {
|
|
var2_2 = this.instance;
|
|
synchronized (var2_2) {
|
|
var4_3 = this.getKnobs();
|
|
var5_4 = var1_1.toArray(new NKnob[var1_1.size()]);
|
|
var6_5 = var4_3.length;
|
|
var7_6 = var5_4.length;
|
|
var8_7 = 0;
|
|
while (true) {
|
|
block9: {
|
|
if (var8_7 < var6_5) break block9;
|
|
var8_7 = 0;
|
|
if (true) ** GOTO lbl36
|
|
}
|
|
var9_8 = false;
|
|
var10_9 = 0;
|
|
while (var10_9 < var7_6) {
|
|
if (var5_4[var10_9] != null && var4_3[var8_7].id == var5_4[var10_9].id) {
|
|
var4_3[var8_7].copyFrom(var5_4[var10_9]);
|
|
var9_8 = true;
|
|
var5_4[var10_9] = null;
|
|
break;
|
|
}
|
|
++var10_9;
|
|
}
|
|
if (!var9_8) {
|
|
this.uninstallKnob(var4_3[var8_7]);
|
|
}
|
|
++var8_7;
|
|
}
|
|
do {
|
|
if (var5_4[var8_7] != null) {
|
|
this.installKnob(var5_4[var8_7], false);
|
|
}
|
|
++var8_7;
|
|
lbl36:
|
|
// 2 sources
|
|
|
|
} while (var8_7 < var7_6);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public int getKnobCount() {
|
|
return this.knobCount;
|
|
}
|
|
|
|
public NKnob[] getKnobs() {
|
|
int n;
|
|
if (this.knobCount == 0) {
|
|
return noKnobs;
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
if (this.frozenKnobs != null) {
|
|
n = 0;
|
|
while (n < this.frozenKnobs.length) {
|
|
if (this.frozenKnobs[n] != null) {
|
|
this.frozenKnobs[n].appendTo(arrayList);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
if (this.table != null) {
|
|
n = 0;
|
|
while (n < this.table.count) {
|
|
NProperty nProperty = this.table.slots[n];
|
|
if (nProperty.knobs != null) {
|
|
nProperty.knobs.appendTo(arrayList);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
return arrayList.toArray(new NKnob[arrayList.size()]);
|
|
}
|
|
|
|
public NKnob[] getKnobs(Slot slot) {
|
|
SlotKnobs slotKnobs = this.getSlotKnobs((NSlot)slot);
|
|
if (slotKnobs == null) {
|
|
return new NKnob[0];
|
|
}
|
|
return slotKnobs.list();
|
|
}
|
|
|
|
public final BValue invoke(Action action, BValue bValue, Context context) {
|
|
return this.invoke(action, bValue, context, false);
|
|
}
|
|
|
|
public final BValue invoke(Action action, BValue bValue, Context context, boolean bl) {
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
return trapCallbacks.invoke(bComponent, action, bValue, context);
|
|
}
|
|
BUser bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.checkInvoke(bComponent, action);
|
|
}
|
|
if (!Flags.isAsync(bComponent, action) || bl) {
|
|
Object object;
|
|
BValue bValue2 = null;
|
|
try {
|
|
if (action.isFrozen()) {
|
|
object = (NAction)action;
|
|
bValue2 = this.invoke(((NAction)object).index, bComponent, bValue, context);
|
|
} else {
|
|
object = (NActionProperty)action;
|
|
BAction bAction = (BAction)((NActionProperty)object).value;
|
|
bValue2 = bAction.invoke(bComponent, bValue);
|
|
}
|
|
}
|
|
catch (UnhandledSlotException unhandledSlotException) {
|
|
unhandledSlotException.printStackTrace();
|
|
throw new NoSuchSlotException(this.getType(), action);
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new ActionInvokeException(throwable);
|
|
}
|
|
try {
|
|
object = this.getSlotKnobs((NSlot)((Object)action));
|
|
if (object != null) {
|
|
((SlotKnobs)object).propagate(bValue);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
this.fireComponentEvent(7, action, bValue, null, context);
|
|
if (bUser != null && !Flags.isNoAudit(bComponent, action)) {
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Invoked", action.getName(), null, ComponentSlotMap.toAuditString(bComponent, action, bValue, context));
|
|
}
|
|
return bValue2;
|
|
}
|
|
try {
|
|
bComponent.post(action, bValue, context);
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final void fire(Topic topic, BValue bValue, Context context) {
|
|
SlotKnobs slotKnobs = this.getSlotKnobs((NSlot)((Object)topic));
|
|
if (slotKnobs != null) {
|
|
slotKnobs.propagate(bValue);
|
|
}
|
|
this.fireComponentEvent(8, topic, bValue, null, context);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void start() {
|
|
if (this.propertyInParent != null && Flags.isNoRun(this.parent.instance, this.propertyInParent)) {
|
|
return;
|
|
}
|
|
if (this.isRunning()) return;
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
boolean bl = this.isSubscribed();
|
|
this.setRunning(true);
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
Nre.engineManager.start(bComponent);
|
|
boolean bl2 = this.isSubscribed();
|
|
if (bl != bl2) {
|
|
this.subscribe(true);
|
|
}
|
|
this.fireComponentEvent(14, null, null, null, null);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void stop() {
|
|
if (!this.isRunning()) return;
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
boolean bl = this.isSubscribed();
|
|
this.setRunning(false);
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
Nre.engineManager.stop(bComponent);
|
|
boolean bl2 = this.isSubscribed();
|
|
if (bl != bl2) {
|
|
this.unsubscribe(true);
|
|
}
|
|
this.fireComponentEvent(15, null, null, null, null);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public final BComplex getParent() {
|
|
if (this.parent == null) {
|
|
return null;
|
|
}
|
|
return this.parent.instance;
|
|
}
|
|
|
|
public final Property getPropertyInParent() {
|
|
return this.propertyInParent;
|
|
}
|
|
|
|
final void parent(NProperty nProperty, ComplexSlotMap complexSlotMap, Context context, TransferListener transferListener, BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder, BDataRecoveryComponentEvent bDataRecoveryComponentEvent) {
|
|
super.parent(nProperty, complexSlotMap, context, transferListener, null, null);
|
|
if (this.space != null) {
|
|
this.space.childParented((BComponent)this.instance, nProperty, complexSlotMap.instance, context);
|
|
}
|
|
this.fireComponentEvent(5, nProperty, complexSlotMap.instance, null, context);
|
|
if (complexSlotMap.instance.isComponent()) {
|
|
ComponentSlotMap componentSlotMap = (ComponentSlotMap)complexSlotMap;
|
|
if (complexSlotMap.isRunning()) {
|
|
throw new IllegalStateException("Child is running?");
|
|
}
|
|
try {
|
|
if (this.space != null) {
|
|
componentSlotMap.mount(this.space, context, transferListener);
|
|
}
|
|
}
|
|
catch (IllegalChildException illegalChildException) {
|
|
super.unparent(nProperty, complexSlotMap, context);
|
|
if (this.space != null) {
|
|
this.space.childUnparented((BComponent)this.instance, nProperty, complexSlotMap.instance, context);
|
|
}
|
|
this.fireComponentEvent(6, nProperty, complexSlotMap.instance, null, context);
|
|
throw illegalChildException;
|
|
}
|
|
if (bDataRecoveryComponentRecorder != null && bDataRecoveryComponentEvent != null) {
|
|
bDataRecoveryComponentRecorder.record(bDataRecoveryComponentEvent, context);
|
|
}
|
|
if (this.isRunning() && ComponentSlotMap.getContextFacet(context, "niagaraAutoStart", true)) {
|
|
complexSlotMap.start();
|
|
}
|
|
} else if (complexSlotMap.instance instanceof BLink) {
|
|
if (bDataRecoveryComponentRecorder != null && bDataRecoveryComponentEvent != null) {
|
|
bDataRecoveryComponentRecorder.record(bDataRecoveryComponentEvent, context);
|
|
}
|
|
if (this.isRunning()) {
|
|
BLink bLink = (BLink)complexSlotMap.instance;
|
|
EngineUtil.activate(bLink);
|
|
}
|
|
} else if (bDataRecoveryComponentRecorder != null && bDataRecoveryComponentEvent != null) {
|
|
bDataRecoveryComponentRecorder.record(bDataRecoveryComponentEvent, context);
|
|
}
|
|
}
|
|
|
|
final void unparent(NProperty nProperty, ComplexSlotMap complexSlotMap, Context context) {
|
|
if (complexSlotMap.instance.isComponent()) {
|
|
ComponentSlotMap componentSlotMap = (ComponentSlotMap)complexSlotMap;
|
|
componentSlotMap.stop();
|
|
if (this.space != null) {
|
|
componentSlotMap.unmount(context);
|
|
}
|
|
} else if (complexSlotMap.instance instanceof BLink) {
|
|
BLink bLink = (BLink)complexSlotMap.instance;
|
|
EngineUtil.deactivate(bLink);
|
|
}
|
|
super.unparent(nProperty, complexSlotMap, context);
|
|
if (this.space != null) {
|
|
this.space.childUnparented((BComponent)this.instance, nProperty, complexSlotMap.instance, context);
|
|
}
|
|
this.fireComponentEvent(6, nProperty, complexSlotMap.instance, null, context);
|
|
}
|
|
|
|
public void deactivating(BLink bLink) {
|
|
try {
|
|
Slot slot = bLink.getTargetSlot();
|
|
if (slot.isProperty() && slot.isFrozen()) {
|
|
Property property = slot.asProperty();
|
|
BValue bValue = property.getDefaultValue().newCopy();
|
|
this.instance.set(property, bValue);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public final void mount(BComponentSpace bComponentSpace, Context context, TransferListener transferListener) {
|
|
Object object;
|
|
if (context != null && context.getUser() != null) {
|
|
if (REQUIRE_SUPER_USER_PERMISSION) {
|
|
if (PROG_CODE_TYPE_INFO == null) {
|
|
PROG_CODE_TYPE_INFO = BTypeSpec.make("program", "Code").getTypeInfo();
|
|
}
|
|
if (PROG_OBJ_TYPE_INFO == null) {
|
|
PROG_OBJ_TYPE_INFO = BTypeSpec.make("program", "Program").getTypeInfo();
|
|
}
|
|
if ((this.getType().is(PROG_CODE_TYPE_INFO) || this.getType().is(PROG_OBJ_TYPE_INFO)) && !context.getUser().getPermissions().isSuperUser()) {
|
|
throw new IllegalChildException("baja", "RestrictedProgramObjException", null);
|
|
}
|
|
}
|
|
if ((this.getType().is(BUserService.TYPE) || this.getType().is(BCategoryService.TYPE)) && !context.getUser().getPermissions().isSuperUser()) {
|
|
throw new IllegalChildException("baja", "RestrictedServiceException", new Object[]{this.getType()});
|
|
}
|
|
if (this.getType().is(BUser.TYPE)) {
|
|
object = context.getUser().getPermissions();
|
|
BPermissionsMap bPermissionsMap = ((BUser)this.instance).getPermissions();
|
|
if (!bPermissionsMap.equals(((BPermissionsMap)object).and(bPermissionsMap))) {
|
|
throw new IllegalChildException("baja", "RestrictedUserAddException", new Object[]{this.getType()});
|
|
}
|
|
}
|
|
}
|
|
bComponentSpace.fw(101, this, null, null, null);
|
|
this.space = bComponentSpace;
|
|
if (this.instance instanceof BIService) {
|
|
Nre.serviceManager.register((BComponent)this.instance);
|
|
}
|
|
if (!bComponentSpace.getLoadCallbacks().isLazyLoad() || this.isBrokerPropsLoaded()) {
|
|
object = this.getProperties();
|
|
int n = 0;
|
|
while (object.nextComponent()) {
|
|
try {
|
|
ComponentSlotMap.getComponentSlotMap(object.get()).mount(bComponentSpace, context, transferListener);
|
|
}
|
|
catch (IllegalChildException illegalChildException) {
|
|
this.unmount(context);
|
|
throw illegalChildException;
|
|
}
|
|
if (transferListener != null && n % 8 == 0) {
|
|
transferListener.updateStatus("Mounting \"" + TransferStrategy.toString(this.instance) + "\"...");
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void unmount(Context context) {
|
|
if (this.instance instanceof BIService) {
|
|
Nre.serviceManager.unregister((BComponent)this.instance);
|
|
}
|
|
NKnob[] nKnobArray = this.getKnobs();
|
|
int n = 0;
|
|
while (n < nKnobArray.length) {
|
|
BLink bLink = nKnobArray[n].getLink();
|
|
if (bLink != null && bLink.isIndirect()) {
|
|
try {
|
|
BComponent bComponent = bLink.getTargetComponent();
|
|
if (ComponentSlotMap.getContextFacet(context, "niagaraRemoveLinks", true)) {
|
|
bComponent.remove(bLink.getPropertyInParent(), Context.commit);
|
|
} else {
|
|
ComponentSlotMap componentSlotMap = ComponentSlotMap.getComponentSlotMap(bComponent);
|
|
EngineUtil.deactivate(bLink);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
this.unsubscribeAll();
|
|
if (this.space != null) {
|
|
this.space.fw(102, this, null, null, null);
|
|
}
|
|
this.space = null;
|
|
SlotCursor slotCursor = this.getProperties();
|
|
while (slotCursor.nextComponent()) {
|
|
ComponentSlotMap.getComponentSlotMap(slotCursor.get()).unmount(context);
|
|
}
|
|
}
|
|
|
|
public final void checkAdd(String string, int n, BValue bValue, BFacets bFacets, Context context) {
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
if (bValue == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
if (bValue == bComponent) {
|
|
throw new IllegalArgumentException("value == this");
|
|
}
|
|
bComponent.checkAdd(string, bValue, n, bFacets, context);
|
|
if (bValue.isComponent()) {
|
|
BComponent bComponent2 = bComponent;
|
|
BComponent bComponent3 = bValue.asComponent();
|
|
boolean bl = bComponent2 instanceof BUnrestrictedFolder;
|
|
if (!bComponent2.isChildLegal(bComponent3)) {
|
|
throw new IllegalChildException("baja", "IllegalChildException.parentAndChild", new Object[]{this.getType(), bValue.getType()});
|
|
}
|
|
if (!bl && !bComponent3.isParentLegal(bComponent2)) {
|
|
throw new IllegalParentException("baja", "IllegalParentException.parentAndChild", new Object[]{this.getType(), bValue.getType()});
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final Property add(String string, int n, BValue bValue, ComplexSlotMap complexSlotMap, BFacets bFacets, Context context, TransferListener transferListener) {
|
|
NProperty nProperty;
|
|
Object object;
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
if (bFacets == null) {
|
|
bFacets = BFacets.NULL;
|
|
}
|
|
this.checkAdd(string, n, bValue, bFacets, context);
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).add(bComponent, string, bValue, n, bFacets, null);
|
|
return null;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
return trapCallbacks.add(bComponent, string, bValue, n, bFacets, context);
|
|
}
|
|
BUser bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
}
|
|
BComponent bComponent2 = bComponent;
|
|
synchronized (bComponent2) {
|
|
block20: {
|
|
block19: {
|
|
if (string != null) break block19;
|
|
string = ObjectUtil.generateUniqueSlotName(bValue.getType().getTypeName(), this);
|
|
break block20;
|
|
}
|
|
if (string.endsWith("?")) {
|
|
object = string.substring(0, string.length() - 1);
|
|
SlotPath.verifyValidName((String)object);
|
|
string = ObjectUtil.generateUniqueSlotName((String)object, this);
|
|
}
|
|
}
|
|
object = this.getSlot(string);
|
|
if (object != null) {
|
|
throw new DuplicateSlotException((Slot)object);
|
|
}
|
|
SlotPath.verifyValidName(string);
|
|
if (!bValue.isSimple() && complexSlotMap.parent != null) {
|
|
throw new AlreadyParentedException(string);
|
|
}
|
|
nProperty = bValue instanceof BAction ? new NActionProperty(string, n, (BAction)bValue, bFacets) : (bValue instanceof BTopic ? new NTopicProperty(string, n, (BTopic)bValue, bFacets) : new NProperty(string, n, bValue, bFacets));
|
|
nProperty.declaringType = bComponent.getType();
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder = this.findRecoveryData(1, nProperty, n, context);
|
|
BDataRecoveryComponentEvent bDataRecoveryComponentEvent = null;
|
|
if (bDataRecoveryComponentRecorder != null) {
|
|
bDataRecoveryComponentEvent = BDataRecoveryComponentEvent.makeAddEvent(bComponent, string, bValue, n, bFacets);
|
|
}
|
|
if (this.table == null) {
|
|
this.table = new DynamicTable(this.getType().slots.length);
|
|
}
|
|
this.table.put(nProperty);
|
|
if (!bValue.isSimple()) {
|
|
try {
|
|
this.parent(nProperty, complexSlotMap, context, transferListener, bDataRecoveryComponentRecorder, bDataRecoveryComponentEvent);
|
|
}
|
|
catch (IllegalChildException illegalChildException) {
|
|
this.table.remove(nProperty);
|
|
throw illegalChildException;
|
|
}
|
|
} else if (bDataRecoveryComponentRecorder != null && bDataRecoveryComponentEvent != null) {
|
|
bDataRecoveryComponentRecorder.record(bDataRecoveryComponentEvent, context);
|
|
}
|
|
}
|
|
this.fireComponentEvent(1, nProperty, null, null, context);
|
|
object = this.checkNavEvent(bValue);
|
|
if (object != null) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeAdded(bComponent, string, context));
|
|
}
|
|
if (bUser != null) {
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Added", nProperty.name, null, ComponentSlotMap.toAuditString(bComponent, nProperty, bValue, context));
|
|
}
|
|
return nProperty;
|
|
}
|
|
|
|
public boolean contains(String string) {
|
|
this.loadSlots();
|
|
boolean bl = false;
|
|
if (this.getSlot(string) != null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final BValue remove(Property property, Context context) {
|
|
NKnob[] nKnobArray;
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder;
|
|
if (property.isFrozen()) {
|
|
throw new FrozenSlotException(property);
|
|
}
|
|
if (this.table == null) {
|
|
throw new NoSuchSlotException(this.getType(), property);
|
|
}
|
|
NKnob[] nKnobArray2 = (NKnob[])this.instance;
|
|
nKnobArray2.checkRemove(property, context);
|
|
NProperty nProperty = (NProperty)property;
|
|
BValue bValue = nProperty.value;
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).remove((BComponent)nKnobArray2, nProperty, null);
|
|
return null;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.remove((BComponent)nKnobArray2, nProperty, context);
|
|
return null;
|
|
}
|
|
BUser bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check((BIProtected)nKnobArray2, BPermissions.adminWrite);
|
|
if (bValue instanceof BIProtected) {
|
|
bUser.check((BIProtected)((Object)bValue), BPermissions.adminWrite);
|
|
}
|
|
}
|
|
if ((bDataRecoveryComponentRecorder = this.findRecoveryData(2, property, context)) != null) {
|
|
bDataRecoveryComponentRecorder.record(BDataRecoveryComponentEvent.makeRemoveEvent((BComponent)nKnobArray2, nProperty.getName()), context);
|
|
}
|
|
try {
|
|
if (!(this.space == null || this.space.isProxyComponentSpace() || bValue instanceof BComponent || bValue instanceof BLink)) {
|
|
nKnobArray = this.getKnobs(nProperty);
|
|
int n = 0;
|
|
while (n < nKnobArray.length) {
|
|
this.removeLink(nKnobArray[n]);
|
|
++n;
|
|
}
|
|
BLink[] bLinkArray = nKnobArray2.getLinks(nProperty);
|
|
int n2 = 0;
|
|
while (n2 < bLinkArray.length) {
|
|
this.removeLink(bLinkArray[n2]);
|
|
++n2;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
nKnobArray = nKnobArray2;
|
|
synchronized (nKnobArray2) {
|
|
block17: {
|
|
if (!bValue.isSimple()) {
|
|
this.unparent(nProperty, ComponentSlotMap.getSlotMap(bValue), context);
|
|
}
|
|
this.table.remove(nProperty);
|
|
nProperty.index = -1;
|
|
// ** MonitorExit[var9_9] (shouldn't be in output)
|
|
this.fireComponentEvent(2, nProperty, bValue, null, context);
|
|
BOrd bOrd = this.checkNavEvent(bValue);
|
|
if (bOrd != null) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeRemoved((BINavNode)nKnobArray2, nProperty.name, context));
|
|
}
|
|
if (bUser == null) break block17;
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Removed", nProperty.name, ComponentSlotMap.toAuditString((BComponent)nKnobArray2, property, bValue, context), null);
|
|
}
|
|
return bValue;
|
|
}
|
|
}
|
|
|
|
private final void removeLink(Knob knob) {
|
|
BComponent bComponent = knob.getTargetComponent();
|
|
BLink bLink = knob.getLink();
|
|
if (bComponent != null && bLink != null) {
|
|
bComponent.remove(bLink);
|
|
}
|
|
}
|
|
|
|
private final void removeLink(BLink bLink) {
|
|
this.remove(bLink.getPropertyInParent(), null);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void rename(Property property, String string, Context context) {
|
|
block13: {
|
|
NProperty nProperty = (NProperty)property;
|
|
if (string.equals(nProperty.name)) {
|
|
return;
|
|
}
|
|
Slot slot = this.getSlot(string);
|
|
SlotPath.verifyValidName(string);
|
|
if (property.isFrozen()) {
|
|
throw new FrozenSlotException(property);
|
|
}
|
|
if (slot != null) {
|
|
throw new DuplicateSlotException(slot);
|
|
}
|
|
if (this.table == null) {
|
|
throw new NoSuchSlotException(this.getType(), property);
|
|
}
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
bComponent.checkRename(property, string, context);
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).rename(bComponent, property, string, null);
|
|
return;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.rename(bComponent, property, string, context);
|
|
return;
|
|
}
|
|
BUser bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
if (nProperty.value instanceof BIProtected) {
|
|
bUser.check((BIProtected)((Object)nProperty.value), BPermissions.adminWrite);
|
|
}
|
|
}
|
|
BValue bValue = null;
|
|
String string2 = null;
|
|
BComponent bComponent2 = bComponent;
|
|
synchronized (bComponent2) {
|
|
string2 = nProperty.name;
|
|
bValue = nProperty.value;
|
|
BObject bObject = this.findRecoveryData(3, nProperty, context);
|
|
if (bObject != null) {
|
|
bObject.record(BDataRecoveryComponentEvent.makeRenameEvent(bComponent, string2, string), context);
|
|
}
|
|
Property[] propertyArray = (Property[])this.table.slots.clone();
|
|
this.table.remove(nProperty);
|
|
nProperty.name = string;
|
|
nProperty.displayName = null;
|
|
this.table.put(nProperty);
|
|
this.table.reorder(propertyArray);
|
|
// MONITOREXIT @DISABLED, blocks:[0, 1] lbl43 : MonitorExitStatement: MONITOREXIT : var11_11
|
|
this.fireComponentEvent(3, nProperty, null, string2, context);
|
|
bObject = this.checkNavEvent(bValue);
|
|
if (bObject != null) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeRenamed(bComponent, string2, string, context));
|
|
}
|
|
if (bUser == null) break block13;
|
|
}
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Renamed", string2, null, string);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void setFacets(Slot slot, BFacets bFacets, Context context) {
|
|
block11: {
|
|
BObject bObject;
|
|
NSlot nSlot;
|
|
if (bFacets == null) {
|
|
bFacets = BFacets.NULL;
|
|
}
|
|
if ((nSlot = (NSlot)slot).isFrozen()) {
|
|
throw new FrozenSlotException(slot);
|
|
}
|
|
if (bFacets.equals(nSlot.facets)) {
|
|
return;
|
|
}
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
bComponent.checkSetFacets(slot, bFacets, context);
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).setFacets(bComponent, nSlot, bFacets, null);
|
|
return;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.setFacets(bComponent, nSlot, bFacets, context);
|
|
return;
|
|
}
|
|
BUser bUser = null;
|
|
String string = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
if (nSlot instanceof NProperty && (bObject = ((NProperty)nSlot).value) instanceof BIProtected) {
|
|
bUser.check((BIProtected)((Object)bObject), BPermissions.adminWrite);
|
|
}
|
|
string = nSlot.facets.toString();
|
|
}
|
|
if ((bObject = this.findRecoveryData(7, nSlot, context)) != null) {
|
|
bObject.record(BDataRecoveryComponentEvent.makeFacetsChangeEvent(bComponent, nSlot.getName(), bFacets), context);
|
|
}
|
|
BComponent bComponent2 = bComponent;
|
|
synchronized (bComponent2) {
|
|
nSlot.facets = bFacets;
|
|
// MONITOREXIT @DISABLED, blocks:[0, 1] lbl30 : MonitorExitStatement: MONITOREXIT : var10_10
|
|
this.fireComponentEvent(10, nSlot, bFacets, null, context);
|
|
if (bUser == null) break block11;
|
|
}
|
|
String string2 = bFacets.toString();
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Facets Changed", nSlot.name, string, string2);
|
|
}
|
|
}
|
|
|
|
public void reorderToTop(Property property, Context context) {
|
|
if (this.table == null || this.table.count == 0) {
|
|
throw new IllegalArgumentException("No dynamic properties");
|
|
}
|
|
if (property.isFrozen()) {
|
|
throw new FrozenSlotException(property);
|
|
}
|
|
Object[] objectArray = new Property[this.table.count];
|
|
this.table.copyInto(objectArray, 0);
|
|
int n = -1;
|
|
int n2 = 0;
|
|
while (n2 < objectArray.length) {
|
|
if (property == objectArray[n2]) {
|
|
n = n2;
|
|
break;
|
|
}
|
|
++n2;
|
|
}
|
|
if (n == -1) {
|
|
throw new IllegalArgumentException("Property not in component");
|
|
}
|
|
if (n == 0) {
|
|
return;
|
|
}
|
|
System.arraycopy(objectArray, 0, objectArray, 1, n);
|
|
objectArray[0] = property;
|
|
this.reorderImpl((Property[])objectArray, context);
|
|
}
|
|
|
|
public void reorderToBottom(Property property, Context context) {
|
|
if (this.table == null || this.table.count == 0) {
|
|
throw new IllegalStateException("No dynamic properties");
|
|
}
|
|
if (property.isFrozen()) {
|
|
throw new FrozenSlotException(property);
|
|
}
|
|
Object[] objectArray = new Property[this.table.count];
|
|
this.table.copyInto(objectArray, 0);
|
|
int n = -1;
|
|
int n2 = 0;
|
|
while (n2 < objectArray.length) {
|
|
if (property == objectArray[n2]) {
|
|
n = n2;
|
|
break;
|
|
}
|
|
++n2;
|
|
}
|
|
if (n == -1) {
|
|
throw new IllegalArgumentException("Property not in component");
|
|
}
|
|
if (n == objectArray.length - 1) {
|
|
return;
|
|
}
|
|
System.arraycopy(objectArray, n + 1, objectArray, n, objectArray.length - n - 1);
|
|
objectArray[objectArray.length - 1] = property;
|
|
this.reorderImpl((Property[])objectArray, context);
|
|
}
|
|
|
|
public void reorder(Property[] propertyArray, Context context) {
|
|
if (this.table == null) {
|
|
throw new ArrayIndexOutOfBoundsException("no dynamic props");
|
|
}
|
|
if (this.table.count != propertyArray.length) {
|
|
throw new ArrayIndexOutOfBoundsException("actual count " + this.table.count + " != param count " + propertyArray.length);
|
|
}
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
if (propertyArray[n].isFrozen()) {
|
|
throw new FrozenSlotException(propertyArray[n]);
|
|
}
|
|
++n;
|
|
}
|
|
this.reorderImpl(propertyArray, context);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
private final void reorderImpl(Property[] propertyArray, Context context) {
|
|
BUser bUser;
|
|
block9: {
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder;
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
bComponent.checkReorder(propertyArray, context);
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).reorder(bComponent, propertyArray, null);
|
|
return;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.reorder(bComponent, propertyArray, context);
|
|
return;
|
|
}
|
|
bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
}
|
|
if ((bDataRecoveryComponentRecorder = this.findRecoveryData(4, null, -1, context)) != null) {
|
|
bDataRecoveryComponentRecorder.record(BDataRecoveryComponentEvent.makeReorderEvent(bComponent, propertyArray), context);
|
|
}
|
|
BComponent bComponent2 = bComponent;
|
|
synchronized (bComponent2) {
|
|
this.table.reorder(propertyArray);
|
|
// MONITOREXIT @DISABLED, blocks:[0, 1] lbl20 : MonitorExitStatement: MONITOREXIT : var7_7
|
|
this.fireComponentEvent(4, null, null, null, context);
|
|
BOrd bOrd = bComponent.getNavOrd();
|
|
if (bOrd == null) break block9;
|
|
}
|
|
String[] stringArray = new String[this.table.count];
|
|
int n = 0;
|
|
while (n < stringArray.length) {
|
|
stringArray[n] = this.table.slots[n].name;
|
|
++n;
|
|
}
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeReordered(bComponent, stringArray, context));
|
|
}
|
|
if (bUser != null) {
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Reordered", null, null, null);
|
|
}
|
|
}
|
|
|
|
public final BCategoryMask getAppliedCategoryMask() {
|
|
if (this.cat.isNull() && this.parent != null) {
|
|
return this.parent.getAppliedCategoryMask();
|
|
}
|
|
return this.cat;
|
|
}
|
|
|
|
public final BCategoryMask getCategoryMask() {
|
|
return this.cat;
|
|
}
|
|
|
|
public final void setCategoryMask(BCategoryMask bCategoryMask, Context context) {
|
|
BComponent bComponent = (BComponent)this.instance;
|
|
if (bCategoryMask == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
if (bCategoryMask == this.cat) {
|
|
return;
|
|
}
|
|
if (context instanceof Transaction) {
|
|
((Transaction)context).setCategoryMask(bComponent, bCategoryMask, null);
|
|
return;
|
|
}
|
|
TrapCallbacks trapCallbacks = this.getSpaceTrap();
|
|
if (trapCallbacks != null && trapCallbacks.isTrapEnabled() && context != Context.commit) {
|
|
trapCallbacks.setCategoryMask(bComponent, bCategoryMask, context);
|
|
return;
|
|
}
|
|
BUser bUser = null;
|
|
if (context != null && context.getUser() != null) {
|
|
bUser = context.getUser();
|
|
bUser.check(bComponent, BPermissions.adminWrite);
|
|
}
|
|
BCategoryMask bCategoryMask2 = this.cat;
|
|
BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder = this.findRecoveryData(10, null, -1, context);
|
|
if (bDataRecoveryComponentRecorder != null) {
|
|
bDataRecoveryComponentRecorder.record(BDataRecoveryComponentEvent.makeRecategorizeEvent(bComponent, bCategoryMask, bCategoryMask2), context);
|
|
}
|
|
this.cat = bCategoryMask;
|
|
this.fireComponentEvent(11, null, bCategoryMask2, null, context);
|
|
BOrd bOrd = bComponent.getNavOrd();
|
|
if (bOrd != null) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeRecategorized(bComponent, bCategoryMask2, bCategoryMask, context));
|
|
}
|
|
if (bUser != null) {
|
|
this.audit(this.getAuditSlotPath(context), bUser, "Recategorized", null, bCategoryMask2.encodeToString(), bCategoryMask.encodeToString());
|
|
}
|
|
}
|
|
|
|
public final BCategoryMask getDeepOrCategoryMask() {
|
|
return this.catDeepOr;
|
|
}
|
|
|
|
public void updateDeepOr(BCategoryMask[] bCategoryMaskArray, int n) {
|
|
bCategoryMaskArray[n + 1] = BCategoryMask.NULL;
|
|
SlotCursor slotCursor = this.getProperties();
|
|
while (slotCursor.nextComponent()) {
|
|
BComponent bComponent = (BComponent)slotCursor.get();
|
|
ComponentSlotMap componentSlotMap = (ComponentSlotMap)bComponent.fw(1, null, null, null, null);
|
|
componentSlotMap.updateDeepOr(bCategoryMaskArray, n + 1);
|
|
}
|
|
this.catDeepOr = bCategoryMaskArray[n + 1];
|
|
bCategoryMaskArray[n] = BCategoryMask.or(BCategoryMask.or(bCategoryMaskArray[n], this.cat), this.catDeepOr);
|
|
}
|
|
|
|
public static boolean getContextFacet(Context context, String string, boolean bl) {
|
|
if (context == null) {
|
|
return bl;
|
|
}
|
|
BBoolean bBoolean = (BBoolean)context.getFacet(string);
|
|
if (bBoolean == null) {
|
|
return bl;
|
|
}
|
|
return bBoolean.getBoolean();
|
|
}
|
|
|
|
final BOrd checkNavEvent(BValue bValue) {
|
|
if (bValue instanceof BComponent && ((BComponent)bValue).isNavChild()) {
|
|
return ((BComponent)this.instance).getNavOrd();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static BOrd swizzle(BOrd bOrd, int n) {
|
|
try {
|
|
if (bOrd.toString().startsWith("h:")) {
|
|
OrdQuery[] ordQueryArray = bOrd.parse();
|
|
ordQueryArray[0] = new BasicQuery("h", ComponentSlotMap.swizzle(ordQueryArray[0].getBody(), n));
|
|
return BOrd.make(ordQueryArray);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
return bOrd;
|
|
}
|
|
|
|
public static String swizzle(String string, int n) {
|
|
String string2 = Integer.toHexString(n);
|
|
return SWIZZLE_PREFIX + string2 + '-' + string;
|
|
}
|
|
|
|
public static String unswizzle(String string) {
|
|
if (!string.startsWith(SWIZZLE_PREFIX)) {
|
|
return string;
|
|
}
|
|
int n = string.indexOf(45, SWIZZLE_PREFIX.length() + 1);
|
|
if (n < 0) {
|
|
return string;
|
|
}
|
|
return string.substring(n + 1);
|
|
}
|
|
|
|
public String generateUniqueSlotName(String string) {
|
|
return ObjectUtil.generateUniqueSlotName(string, this);
|
|
}
|
|
|
|
public final boolean isInitialized() {
|
|
boolean bl = false;
|
|
if ((this.mask & 1) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final void setInitialized(boolean bl) {
|
|
this.mask = bl ? (this.mask |= 1) : (this.mask &= 0xFFFFFFFE);
|
|
}
|
|
|
|
public final boolean isRunning() {
|
|
boolean bl = false;
|
|
if ((this.mask & 4) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final void setRunning(boolean bl) {
|
|
this.mask = bl ? (this.mask |= 4) : (this.mask &= 0xFFFFFFFB);
|
|
}
|
|
|
|
public final boolean isBrokerPropsLoaded() {
|
|
boolean bl = false;
|
|
if ((this.mask & 8) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final void setBrokerPropsLoaded(boolean bl) {
|
|
this.mask = bl ? (this.mask |= 8) : (this.mask &= 0xFFFFFFF7);
|
|
}
|
|
|
|
public final boolean isPendingMove() {
|
|
boolean bl = false;
|
|
if ((this.mask & 0x10) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final void setPendingMove(boolean bl) {
|
|
this.mask = bl ? (this.mask |= 0x10) : (this.mask &= 0xFFFFFFEF);
|
|
}
|
|
|
|
public final boolean isWidget() {
|
|
boolean bl = false;
|
|
if ((this.mask & 0x40) != 0) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public final void setIsWidget(boolean bl) {
|
|
this.mask = bl ? (this.mask |= 0x40) : (this.mask &= 0xFFFFFFBF);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void setPendingSubscribe(Subscriber subscriber) {
|
|
if (this.space == null) return;
|
|
if (!this.space.isProxyComponentSpace()) return;
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
int n = this.subscribers.length;
|
|
boolean bl = true;
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
Subscriber subscriber2 = this.subscribers[n2];
|
|
if (subscriber2 instanceof PendingSubscriber && ((PendingSubscriber)subscriber2).subscriber == subscriber) {
|
|
return;
|
|
}
|
|
++n2;
|
|
}
|
|
if (!bl) return;
|
|
Subscriber[] subscriberArray = new Subscriber[this.subscribers.length + 1];
|
|
System.arraycopy(this.subscribers, 0, subscriberArray, 0, this.subscribers.length);
|
|
subscriberArray[this.subscribers.length] = new PendingSubscriber(subscriber);
|
|
this.subscribers = subscriberArray;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public final void clearPendingSubscribe(Subscriber subscriber) {
|
|
BComplex bComplex = this.instance;
|
|
synchronized (bComplex) {
|
|
int n = 0;
|
|
while (n < this.subscribers.length) {
|
|
if (this.subscribers[n] instanceof PendingSubscriber && ((PendingSubscriber)this.subscribers[n]).subscriber == subscriber) {
|
|
Subscriber[] subscriberArray = new Subscriber[this.subscribers.length - 1];
|
|
System.arraycopy(this.subscribers, 0, subscriberArray, 0, n);
|
|
if (n < this.subscribers.length) {
|
|
System.arraycopy(this.subscribers, n + 1, subscriberArray, n, this.subscribers.length - n - 1);
|
|
}
|
|
this.subscribers = subscriberArray;
|
|
break;
|
|
}
|
|
++n;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.table = null;
|
|
this.frozenKnobs = null;
|
|
this.subscribers = noSubscribers;
|
|
this.mask = 0;
|
|
this.cat = BCategoryMask.NULL;
|
|
this.catDeepOr = BCategoryMask.NULL;
|
|
}
|
|
|
|
public ComponentSlotMap() {
|
|
this.this();
|
|
}
|
|
|
|
static {
|
|
int[] nArray = new int[16];
|
|
nArray[1] = 1;
|
|
nArray[2] = 2;
|
|
nArray[3] = 3;
|
|
nArray[4] = 4;
|
|
nArray[5] = -1;
|
|
nArray[6] = -1;
|
|
nArray[7] = -1;
|
|
nArray[8] = 5;
|
|
nArray[9] = 6;
|
|
nArray[10] = 7;
|
|
nArray[11] = 10;
|
|
nArray[12] = 8;
|
|
nArray[13] = 9;
|
|
nArray[14] = 19;
|
|
nArray[15] = 20;
|
|
COMPONENT_EVENT = nArray;
|
|
COMPONENT_CHILD_EVENT = new int[]{-1, 11, 12, 13, 14, -1, -1, -1, -1, 15, 16, -1, -1, -1, -1, -1};
|
|
REQUIRE_SUPER_USER_PERMISSION = Boolean.valueOf(System.getProperty("niagara.program.requireSuperUser", "true"));
|
|
PROG_OBJ_TYPE_INFO = null;
|
|
PROG_CODE_TYPE_INFO = null;
|
|
noSubscribers = new Subscriber[0];
|
|
noKnobs = new NKnob[0];
|
|
}
|
|
|
|
static class PendingSubscriber
|
|
extends Subscriber {
|
|
Subscriber subscriber;
|
|
|
|
public void event(BComponentEvent bComponentEvent) {
|
|
this.subscriber.event(bComponentEvent);
|
|
}
|
|
|
|
public PendingSubscriber(Subscriber subscriber) {
|
|
this.subscriber = subscriber;
|
|
}
|
|
}
|
|
}
|
|
|