383 lines
12 KiB
Java
383 lines
12 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
package javax.baja.sync;
|
|
|
|
import com.tridium.sys.transfer.TransferListener;
|
|
import com.tridium.sys.transfer.TransferStrategy;
|
|
import java.util.HashMap;
|
|
import javax.baja.category.BCategoryMask;
|
|
import javax.baja.io.ValueDocDecoder;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.sync.AddOp;
|
|
import javax.baja.sync.LoadOp;
|
|
import javax.baja.sync.RemoveOp;
|
|
import javax.baja.sync.RenameOp;
|
|
import javax.baja.sync.ReorderOp;
|
|
import javax.baja.sync.SetCategoryMaskOp;
|
|
import javax.baja.sync.SetFacetsOp;
|
|
import javax.baja.sync.SetFlagsOp;
|
|
import javax.baja.sync.SetOp;
|
|
import javax.baja.sync.SyncDecoder;
|
|
import javax.baja.sync.SyncEncoder;
|
|
import javax.baja.sync.SyncOp;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.BasicContext;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class SyncBuffer {
|
|
static BFacets noAutoStartFacets;
|
|
BComponentSpace space;
|
|
OpLinkedList loads;
|
|
OpLinkedList ops;
|
|
boolean coalesce;
|
|
HashMap propChanges;
|
|
TransferListener listener;
|
|
boolean checkForAutoStart;
|
|
|
|
public BComponentSpace getSpace() {
|
|
return this.space;
|
|
}
|
|
|
|
public boolean isCoalesced() {
|
|
return this.coalesce;
|
|
}
|
|
|
|
public void encode(SyncEncoder syncEncoder) throws Exception {
|
|
syncEncoder.start("sync").attr("ver", "1.0").endAttr().newLine();
|
|
syncEncoder.startArray("ops");
|
|
SyncOp[] syncOpArray = this.list();
|
|
int n = 0;
|
|
while (n < syncOpArray.length) {
|
|
try {
|
|
syncOpArray[n].encode(syncEncoder);
|
|
}
|
|
catch (SyncOp.SyncOpSecurityException syncOpSecurityException) {}
|
|
++n;
|
|
}
|
|
syncEncoder.endArray();
|
|
syncEncoder.end("sync").newLine();
|
|
}
|
|
|
|
public void decode(SyncDecoder syncDecoder) throws Exception {
|
|
if (this.loads.head != null || this.ops.head != null) {
|
|
throw new IllegalStateException("Already contains changes");
|
|
}
|
|
ValueDocDecoder.IElement iElement = syncDecoder.elem();
|
|
if (iElement == null) {
|
|
syncDecoder.next();
|
|
iElement = syncDecoder.elem();
|
|
}
|
|
if (iElement == null) {
|
|
return;
|
|
}
|
|
if (!iElement.name().equals("sync")) {
|
|
throw syncDecoder.err("Invalid root element " + iElement.name());
|
|
}
|
|
while (true) {
|
|
int n;
|
|
if ((n = syncDecoder.next()) == 2) {
|
|
if (syncDecoder.elem().name().equals("sync")) break;
|
|
throw syncDecoder.err("Expected end sync");
|
|
}
|
|
if (n != 1) {
|
|
throw syncDecoder.err("Expected element start");
|
|
}
|
|
int n2 = syncDecoder.depth();
|
|
ValueDocDecoder.IElement iElement2 = syncDecoder.elem();
|
|
char c = iElement2.name().charAt(0);
|
|
SyncOp syncOp = SyncOp.make(c);
|
|
syncOp.decode(this, this.space, syncDecoder);
|
|
this.add(syncOp);
|
|
syncDecoder.skip(n2);
|
|
}
|
|
}
|
|
|
|
public final void commit() throws Exception {
|
|
this.commit(null);
|
|
}
|
|
|
|
protected SyncOp[] startCommit(SyncOp[] syncOpArray, Context context) {
|
|
return syncOpArray;
|
|
}
|
|
|
|
protected void endCommit() throws Exception {
|
|
}
|
|
|
|
protected void abortCommit(Exception exception) {
|
|
}
|
|
|
|
public void commit(Context context) throws Exception {
|
|
SyncOp[] syncOpArray = this.startCommit(this.list(), context);
|
|
try {
|
|
Context context2 = context;
|
|
if (!this.space.isProxyComponentSpace()) {
|
|
context2 = new BasicContext(context, noAutoStartFacets);
|
|
}
|
|
int n = 0;
|
|
while (n < syncOpArray.length) {
|
|
if (!syncOpArray[n].committed) {
|
|
this.commitOp(syncOpArray[n], context2);
|
|
}
|
|
++n;
|
|
}
|
|
if (this.checkForAutoStart) {
|
|
this.checkForAutoStart = false;
|
|
n = 0;
|
|
while (n < syncOpArray.length) {
|
|
try {
|
|
SyncOp syncOp = syncOpArray[n];
|
|
if (syncOp instanceof AddOp) {
|
|
this.checkAutoStart(((AddOp)syncOp).value);
|
|
}
|
|
if (syncOp instanceof SetOp) {
|
|
this.checkAutoStart(((SetOp)syncOp).value);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
this.endCommit();
|
|
}
|
|
catch (Exception exception) {
|
|
this.abortCommit(exception);
|
|
throw exception;
|
|
}
|
|
}
|
|
|
|
protected void commitOp(SyncOp syncOp, Context context) throws Exception {
|
|
block7: {
|
|
try {
|
|
if (syncOp.committed) {
|
|
return;
|
|
}
|
|
syncOp.committed = true;
|
|
if (syncOp.component == null) {
|
|
try {
|
|
syncOp.component = this.findByHandle(syncOp.handle, false);
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
if (syncOp.component != null) {
|
|
syncOp.commit(this, this.space, context);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
System.out.println("ERROR: SyncOp.commit: " + syncOp);
|
|
exception.printStackTrace();
|
|
if (this.space.isProxyComponentSpace()) break block7;
|
|
throw exception;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void checkAutoStart(BValue bValue) {
|
|
BComponent bComponent;
|
|
BComponent bComponent2;
|
|
if (bValue instanceof BComponent && (bComponent2 = (BComponent)(bComponent = (BComponent)bValue).getParent()) != null && bComponent2.isRunning()) {
|
|
if (this.listener != null) {
|
|
this.listener.updateStatus("Starting \"" + TransferStrategy.toString(bComponent) + "\"...");
|
|
}
|
|
bComponent.start();
|
|
}
|
|
}
|
|
|
|
protected BComponent findByHandle(Object object, boolean bl) {
|
|
return this.space.findByHandle(object, bl);
|
|
}
|
|
|
|
public void set(BComponent bComponent, Property[] propertyArray, BValue bValue, Context context) {
|
|
String string;
|
|
if (this.coalesce) {
|
|
this.add(new SetOp(bComponent, propertyArray[0].getName(), null));
|
|
return;
|
|
}
|
|
if (propertyArray.length == 1) {
|
|
string = propertyArray[0].getName();
|
|
} else {
|
|
StringBuffer stringBuffer = new StringBuffer(propertyArray[0].getName());
|
|
int n = 1;
|
|
while (n < propertyArray.length) {
|
|
stringBuffer.append('/').append(propertyArray[n].getName());
|
|
++n;
|
|
}
|
|
string = stringBuffer.toString();
|
|
}
|
|
this.add(new SetOp(bComponent, string, bValue));
|
|
}
|
|
|
|
public void add(BComponent bComponent, String string, BValue bValue, int n, BFacets bFacets, Context context) {
|
|
this.add(new AddOp(bComponent, string, bValue, n, bFacets));
|
|
}
|
|
|
|
public void remove(BComponent bComponent, Property property, Context context) {
|
|
this.add(new RemoveOp(bComponent, property.getName()));
|
|
}
|
|
|
|
public void rename(BComponent bComponent, Property property, String string, Context context) {
|
|
this.add(new RenameOp(bComponent, property.getName(), string));
|
|
}
|
|
|
|
public void reorder(BComponent bComponent, Property[] propertyArray, Context context) {
|
|
String[] stringArray = new String[propertyArray.length];
|
|
int n = 0;
|
|
while (n < stringArray.length) {
|
|
stringArray[n] = propertyArray[n].getName();
|
|
++n;
|
|
}
|
|
this.add(new ReorderOp(bComponent, stringArray));
|
|
}
|
|
|
|
public void setFlags(BComponent bComponent, Slot slot, int n, Context context) {
|
|
this.add(new SetFlagsOp(bComponent, slot.getName(), n));
|
|
}
|
|
|
|
public void setFacets(BComponent bComponent, Slot slot, BFacets bFacets, Context context) {
|
|
this.add(new SetFacetsOp(bComponent, slot.getName(), bFacets));
|
|
}
|
|
|
|
public void setCategoryMask(BComponent bComponent, BCategoryMask bCategoryMask, Context context) {
|
|
this.add(new SetCategoryMaskOp(bComponent, bCategoryMask));
|
|
}
|
|
|
|
public synchronized SyncOp[] list() {
|
|
SyncOp[] syncOpArray = new SyncOp[this.loads.size + this.ops.size];
|
|
int n = 0;
|
|
SyncOp syncOp = this.loads.head;
|
|
while (syncOp != null) {
|
|
syncOpArray[n] = syncOp;
|
|
syncOp = syncOp.next;
|
|
++n;
|
|
}
|
|
syncOp = this.ops.head;
|
|
while (syncOp != null) {
|
|
syncOpArray[n] = syncOp;
|
|
syncOp = syncOp.next;
|
|
++n;
|
|
}
|
|
return syncOpArray;
|
|
}
|
|
|
|
public synchronized void add(SyncOp syncOp) {
|
|
if (syncOp.prev != null || syncOp.next != null) {
|
|
throw new IllegalStateException("Already in linked list " + syncOp);
|
|
}
|
|
if (this.coalesce && syncOp instanceof SetOp) {
|
|
this.addSet((SetOp)syncOp);
|
|
} else if (syncOp instanceof LoadOp) {
|
|
this.loads.append(syncOp);
|
|
} else {
|
|
this.ops.append(syncOp);
|
|
}
|
|
}
|
|
|
|
private final void addSet(SetOp setOp) {
|
|
BComponent bComponent = setOp.component;
|
|
String string = setOp.name;
|
|
HashMap<String, SetOp> hashMap = (HashMap<String, SetOp>)this.propChanges.get(bComponent);
|
|
if (hashMap != null) {
|
|
SetOp setOp2 = (SetOp)hashMap.get(string);
|
|
if (setOp2 != null) {
|
|
this.ops.remove(setOp2);
|
|
}
|
|
} else {
|
|
hashMap = new HashMap<String, SetOp>(13);
|
|
this.propChanges.put(bComponent, hashMap);
|
|
}
|
|
hashMap.put(string, setOp);
|
|
this.ops.append(setOp);
|
|
}
|
|
|
|
public void fw(Object object) {
|
|
if (object instanceof TransferListener) {
|
|
this.listener = (TransferListener)object;
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.checkForAutoStart = true;
|
|
}
|
|
|
|
public SyncBuffer(BComponentSpace bComponentSpace, boolean bl) {
|
|
this.this();
|
|
this.space = bComponentSpace;
|
|
this.loads = new OpLinkedList();
|
|
this.ops = new OpLinkedList();
|
|
this.coalesce = bl;
|
|
if (bl) {
|
|
this.propChanges = new HashMap();
|
|
}
|
|
}
|
|
|
|
static {
|
|
HashMap<String, BBoolean> hashMap = new HashMap<String, BBoolean>();
|
|
hashMap.put("niagaraAutoStart", BBoolean.FALSE);
|
|
noAutoStartFacets = BFacets.make(hashMap);
|
|
}
|
|
|
|
static class OpLinkedList {
|
|
SyncOp head;
|
|
SyncOp tail;
|
|
int size;
|
|
|
|
void append(SyncOp syncOp) {
|
|
if (this.tail == null) {
|
|
this.head = this.tail = syncOp;
|
|
} else {
|
|
this.tail.next = syncOp;
|
|
syncOp.prev = this.tail;
|
|
this.tail = syncOp;
|
|
}
|
|
++this.size;
|
|
}
|
|
|
|
void remove(SyncOp syncOp) {
|
|
SyncOp syncOp2 = syncOp.prev;
|
|
SyncOp syncOp3 = syncOp.next;
|
|
if (syncOp2 != null) {
|
|
syncOp2.next = syncOp3;
|
|
} else {
|
|
this.head = syncOp3;
|
|
}
|
|
if (syncOp3 != null) {
|
|
syncOp3.prev = syncOp2;
|
|
} else {
|
|
this.tail = syncOp2;
|
|
}
|
|
--this.size;
|
|
}
|
|
|
|
void replace(SyncOp syncOp, SyncOp syncOp2) {
|
|
syncOp2.prev = syncOp.prev;
|
|
syncOp2.next = syncOp.next;
|
|
if (syncOp.prev != null) {
|
|
syncOp.prev.next = syncOp2;
|
|
} else {
|
|
this.head = syncOp2;
|
|
}
|
|
if (syncOp.next != null) {
|
|
syncOp.next.prev = syncOp2;
|
|
} else {
|
|
this.tail = syncOp2;
|
|
}
|
|
}
|
|
|
|
OpLinkedList() {
|
|
}
|
|
}
|
|
}
|
|
|