257 lines
10 KiB
Java
257 lines
10 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
package javax.baja.sync;
|
|
|
|
import com.tridium.sys.engine.ProxyKnob;
|
|
import com.tridium.sys.schema.ComponentSlotMap;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import javax.baja.io.ValueDocDecoder;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.sync.SyncBuffer;
|
|
import javax.baja.sync.SyncDecoder;
|
|
import javax.baja.sync.SyncEncoder;
|
|
import javax.baja.sync.SyncOp;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BSimple;
|
|
import javax.baja.sys.BStruct;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.SlotCursor;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class LoadOp
|
|
extends SyncOp {
|
|
int depth;
|
|
BComponent current;
|
|
HashMap knobs;
|
|
boolean partialLoad;
|
|
|
|
public int getId() {
|
|
return 108;
|
|
}
|
|
|
|
public int getDepth() {
|
|
return this.depth;
|
|
}
|
|
|
|
void commit(SyncBuffer syncBuffer, BComponentSpace bComponentSpace, Context context) throws Exception {
|
|
this.syncComponent(this.current, this.component, this.partialLoad);
|
|
if (!this.partialLoad) {
|
|
this.loadKnobs(bComponentSpace);
|
|
}
|
|
}
|
|
|
|
void syncComponent(BComponent bComponent, BComponent bComponent2, boolean bl) throws Exception {
|
|
Object object;
|
|
Object object2;
|
|
if (bComponent.getType() != bComponent2.getType()) {
|
|
throw new IllegalStateException(bComponent.getType() + " != " + bComponent2.getType());
|
|
}
|
|
if (bComponent2.getHandle() == null || !bComponent2.getHandle().equals(bComponent.getHandle())) {
|
|
throw new IllegalStateException("from.h != to.h -> " + bComponent.getHandle() + " != " + bComponent2.getHandle());
|
|
}
|
|
ComponentSlotMap componentSlotMap = (ComponentSlotMap)bComponent.fw(1);
|
|
ComponentSlotMap componentSlotMap2 = (ComponentSlotMap)bComponent2.fw(1);
|
|
componentSlotMap2.setCachedPermissions(componentSlotMap.getCachedPermissions());
|
|
componentSlotMap2.setCategoryMask(componentSlotMap.getCategoryMask(), Context.commit);
|
|
boolean bl2 = ((ComponentSlotMap)bComponent.fw(1)).isBrokerPropsLoaded();
|
|
if (!bl2) {
|
|
this.syncIcon(bComponent, bComponent2);
|
|
if (!bl) {
|
|
return;
|
|
}
|
|
}
|
|
if (!bl) {
|
|
((ComponentSlotMap)bComponent2.fw(1)).setBrokerPropsLoaded(true);
|
|
}
|
|
HashMap<String, Property> hashMap = new HashMap<String, Property>();
|
|
Property[] propertyArray = bComponent2.getPropertiesArray();
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
hashMap.put(propertyArray[n].getName(), propertyArray[n]);
|
|
++n;
|
|
}
|
|
SlotCursor slotCursor = bComponent.getSlots();
|
|
while (slotCursor.next()) {
|
|
object2 = slotCursor.slot().getName();
|
|
object = slotCursor.slot();
|
|
Slot slot = bComponent2.getSlot((String)object2);
|
|
int n2 = bComponent.getFlags((Slot)object);
|
|
if (slot == null) {
|
|
Property property = (Property)object;
|
|
BValue bValue = bComponent.get(property);
|
|
BValue bValue2 = this.newCopy(bValue);
|
|
bComponent2.add((String)object2, bValue2, n2, bComponent.getSlotFacets(property), Context.commit);
|
|
if (!bValue.isComponent()) continue;
|
|
this.syncComponent((BComponent)bValue, (BComponent)bValue2, false);
|
|
continue;
|
|
}
|
|
hashMap.remove(object2);
|
|
bComponent2.setFlags(slot, n2, Context.commit);
|
|
if (!object.isProperty()) continue;
|
|
this.syncValue(bComponent, (Property)object, bComponent2, (Property)slot, false);
|
|
}
|
|
if (hashMap.size() > 0) {
|
|
object2 = hashMap.keySet().iterator();
|
|
while (object2.hasNext()) {
|
|
object = (String)object2.next();
|
|
bComponent2.remove((String)object, Context.commit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void syncValue(BComplex bComplex, Property property, BComplex bComplex2, Property property2, boolean bl) throws Exception {
|
|
BValue bValue = bComplex.get(property);
|
|
BValue bValue2 = bComplex2.get(property2);
|
|
if (bValue.getClass() != bValue2.getClass() || bValue.isSimple() || bValue2.isComponent() && (bValue2.asComponent().getHandle() == null || bValue2.asComponent().getComponentSpace() == null)) {
|
|
if (bValue.isComponent() && bValue.asComponent().getHandle() == null) {
|
|
if (bValue.asComponent().getPropertyInParent().isDynamic()) {
|
|
throw new IllegalStateException("LoadOp - dynamic slot with no handle");
|
|
}
|
|
System.out.println("WARNING: remote VM does not have frozen slot \"" + bComplex.getType() + '.' + property.getName() + '\"');
|
|
bComplex2.setFlags(property2, bComplex2.getFlags(property2) | 4, Context.commit);
|
|
return;
|
|
}
|
|
bValue2 = this.newCopy(bValue);
|
|
bComplex2.set(property2, bValue2, Context.commit);
|
|
if (bValue.isComponent()) {
|
|
this.syncComponent((BComponent)bValue, (BComponent)bValue2, bl);
|
|
}
|
|
return;
|
|
}
|
|
if (bValue.isComponent()) {
|
|
BComponent bComponent = (BComponent)bValue;
|
|
BComponent bComponent2 = (BComponent)bValue2;
|
|
if (bComponent2.getHandle() == null) {
|
|
throw new IllegalStateException();
|
|
}
|
|
this.syncComponent(bComponent, bComponent2, bl);
|
|
return;
|
|
}
|
|
BStruct bStruct = (BStruct)bValue;
|
|
BStruct bStruct2 = (BStruct)bValue2;
|
|
SlotCursor slotCursor = bStruct.getProperties();
|
|
while (slotCursor.next()) {
|
|
Property property3;
|
|
Property property4 = slotCursor.property();
|
|
if (property4 != (property3 = bStruct2.getProperty(property4.getName()))) {
|
|
throw new IllegalStateException("Structs should have same prop " + property4 + " != " + property3);
|
|
}
|
|
this.syncValue(bStruct, property4, bStruct2, property3, bl);
|
|
}
|
|
}
|
|
|
|
BValue newCopy(BValue bValue) {
|
|
if (bValue.isComponent()) {
|
|
BComponent bComponent = (BComponent)bValue;
|
|
BComponent bComponent2 = (BComponent)bComponent.getType().getInstance();
|
|
((ComponentSlotMap)bComponent2.fw(1)).setHandle(bComponent.getHandle());
|
|
return bComponent2;
|
|
}
|
|
return bValue.newCopy(true);
|
|
}
|
|
|
|
void loadKnobs(BComponentSpace bComponentSpace) throws Exception {
|
|
Iterator iterator = this.knobs.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
BComponent bComponent = (BComponent)iterator.next();
|
|
if (!((ComponentSlotMap)bComponent.fw(1)).isBrokerPropsLoaded()) continue;
|
|
BComponent bComponent2 = bComponentSpace.findByHandle(bComponent.getHandle(), false);
|
|
if (bComponent2 == null) {
|
|
throw new IllegalStateException("" + bComponent.getHandle());
|
|
}
|
|
ArrayList arrayList = (ArrayList)this.knobs.get(bComponent);
|
|
ArrayList<ProxyKnob> arrayList2 = new ArrayList<ProxyKnob>(arrayList.size());
|
|
int n = 0;
|
|
while (n < arrayList.size()) {
|
|
ValueDocDecoder.IElement iElement = (ValueDocDecoder.IElement)arrayList.get(n);
|
|
ProxyKnob proxyKnob = SyncDecoder.decodeKnob(bComponent2, iElement);
|
|
if (proxyKnob != null) {
|
|
arrayList2.add(proxyKnob);
|
|
}
|
|
++n;
|
|
}
|
|
((ComponentSlotMap)bComponent2.fw(1)).mergeKnobs(arrayList2);
|
|
}
|
|
}
|
|
|
|
void syncIcon(BComponent bComponent, BComponent bComponent2) {
|
|
Property property = bComponent.getProperty("icon");
|
|
if (property == null) {
|
|
return;
|
|
}
|
|
BValue bValue = bComponent.get(property);
|
|
if (!(bValue instanceof BSimple)) {
|
|
return;
|
|
}
|
|
Property property2 = bComponent2.getProperty("icon");
|
|
if (property2 == null) {
|
|
bComponent2.add("icon", bValue, Context.commit);
|
|
} else {
|
|
bComponent2.set(property2, bValue, Context.commit);
|
|
}
|
|
}
|
|
|
|
void encode(SyncEncoder syncEncoder) throws Exception {
|
|
super.encode(syncEncoder);
|
|
if (this.partialLoad) {
|
|
syncEncoder.attr("partialLoad", true);
|
|
}
|
|
syncEncoder.endAttr().newLine().key("b");
|
|
syncEncoder.encodeForLoad = true;
|
|
boolean bl = syncEncoder.setEncodeTransients(true);
|
|
syncEncoder.encode(null, this.component, this.depth);
|
|
syncEncoder.setEncodeTransients(bl);
|
|
syncEncoder.encodeForLoad = true;
|
|
syncEncoder.end(String.valueOf((char)this.getId())).newLine();
|
|
}
|
|
|
|
void decode(SyncBuffer syncBuffer, BComponentSpace bComponentSpace, SyncDecoder syncDecoder) throws Exception {
|
|
super.decode(syncBuffer, bComponentSpace, syncDecoder);
|
|
ValueDocDecoder.IElement iElement = syncDecoder.elem();
|
|
this.partialLoad = iElement.get("partialLoad", "false").equals("true");
|
|
syncDecoder.knobs = null;
|
|
syncDecoder.next();
|
|
this.current = (BComponent)syncDecoder.decode();
|
|
this.knobs = syncDecoder.knobs;
|
|
syncDecoder.knobs = null;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
stringBuffer.append("Load: " + this.componentToString());
|
|
if (this.partialLoad) {
|
|
stringBuffer.append(", partialLoad enabled");
|
|
}
|
|
return stringBuffer.toString();
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.partialLoad = false;
|
|
}
|
|
|
|
public LoadOp(BComponent bComponent, int n) {
|
|
super(bComponent);
|
|
this.this();
|
|
this.depth = n;
|
|
}
|
|
|
|
public LoadOp() {
|
|
this.this();
|
|
}
|
|
|
|
public LoadOp(BComponent bComponent, int n, boolean bl) {
|
|
this(bComponent, n);
|
|
this.partialLoad = bl;
|
|
}
|
|
}
|
|
|