343 lines
11 KiB
Java
343 lines
11 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
package com.tridium.sys.transfer;
|
|
|
|
import com.tridium.space.BGateway;
|
|
import com.tridium.sys.transfer.CompToBog;
|
|
import com.tridium.sys.transfer.CompToComp;
|
|
import com.tridium.sys.transfer.FileToComp;
|
|
import com.tridium.sys.transfer.FileToFile;
|
|
import com.tridium.sys.transfer.IntraFileSpaceMove;
|
|
import com.tridium.sys.transfer.RemoteIntraSpace;
|
|
import com.tridium.sys.transfer.RemoteTransferSpace;
|
|
import com.tridium.sys.transfer.TransferListener;
|
|
import com.tridium.sys.transfer.TransferResult;
|
|
import javax.baja.file.BDirectory;
|
|
import javax.baja.file.BFileSpace;
|
|
import javax.baja.file.BIFile;
|
|
import javax.baja.file.FilePath;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.space.BISpaceNode;
|
|
import javax.baja.space.BSpace;
|
|
import javax.baja.space.Mark;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BInteger;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BString;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.virtual.BVirtualGateway;
|
|
|
|
public abstract class TransferStrategy {
|
|
public static final int ACTION_COPY = 16;
|
|
public static final int ACTION_MOVE = 32;
|
|
public static final String PARAM_EXACT = "exact";
|
|
public static final String PARAM_ORIGIN = "origin";
|
|
public static final String PARAM_COPY_SOURCE = "copySource";
|
|
public static final String PARAM_KEEP_ALL_LINKS = "keepAllLinks";
|
|
public static final Log log = Log.getLog("sys.transfer");
|
|
int action;
|
|
BObject target;
|
|
Mark mark;
|
|
Context context;
|
|
BComponent params;
|
|
TransferListener listener;
|
|
|
|
public static TransferStrategy make(int n, Mark mark, BObject bObject, BComponent bComponent, Context context) {
|
|
Object object;
|
|
if (TransferStrategy.isDebugOn()) {
|
|
TransferStrategy.debug("====== TransferStrategy.make ======");
|
|
TransferStrategy.debug(" action = " + n);
|
|
TransferStrategy.debug(" mark = " + mark);
|
|
TransferStrategy.debug(" target = " + bObject);
|
|
TransferStrategy.debug(" params = " + bComponent);
|
|
TransferStrategy.debug(" context = " + context);
|
|
}
|
|
bObject = TransferStrategy.toActualTarget(bObject);
|
|
if (mark.getValues().length == 1) {
|
|
object = mark.getNames()[0];
|
|
BObject bObject2 = mark.getValues()[0];
|
|
if (bObject2 instanceof BComponentSpace) {
|
|
BComponent bComponent2 = ((BComponentSpace)bObject2).getRootComponent();
|
|
mark = new Mark(bComponent2, (String)object);
|
|
}
|
|
}
|
|
if ((object = TransferStrategy.makeImpl(n, mark, bObject, context)) == null) {
|
|
return null;
|
|
}
|
|
if (TransferStrategy.isDebugOn()) {
|
|
TransferStrategy.debug(" class = " + object.getClass().getName());
|
|
}
|
|
((TransferStrategy)object).action = n;
|
|
((TransferStrategy)object).mark = mark;
|
|
((TransferStrategy)object).target = bObject;
|
|
((TransferStrategy)object).params = bComponent;
|
|
((TransferStrategy)object).context = context;
|
|
return object;
|
|
}
|
|
|
|
public static BObject toActualTarget(BObject bObject) {
|
|
BComponent bComponent;
|
|
BComponentSpace bComponentSpace;
|
|
if (bObject instanceof BGateway) {
|
|
bObject = ((BGateway)bObject).getGatewaySpace();
|
|
}
|
|
if (bObject instanceof BComponentSpace) {
|
|
return ((BComponentSpace)bObject).getRootComponent();
|
|
}
|
|
if (bObject.getType().getTypeName().equals("FoxFileSpace")) {
|
|
return (BObject)((Object)((BFileSpace)bObject).resolveFile(new FilePath("^")));
|
|
}
|
|
if (bObject.getType().getTypeName().equals("BogFile")) {
|
|
return BOrd.make("bog:|slot:/").get(bObject);
|
|
}
|
|
if (bObject.getType().getTypeName().equals("SaxFile")) {
|
|
return BOrd.make("sax:|slot:/").get(bObject);
|
|
}
|
|
if (bObject instanceof BVirtualGateway && (bComponentSpace = ((BVirtualGateway)bObject).getVirtualSpace()) != null && (bComponent = bComponentSpace.getRootComponent()) != null) {
|
|
bComponent.loadSlots();
|
|
return bComponent;
|
|
}
|
|
return bObject;
|
|
}
|
|
|
|
static TransferStrategy makeImpl(int n, Mark mark, BObject bObject, Context context) {
|
|
if (bObject instanceof BComponent) {
|
|
return TransferStrategy.toComp(n, mark, (BComponent)bObject, context);
|
|
}
|
|
if (bObject instanceof BIFile) {
|
|
return TransferStrategy.toFile(n, mark, (BIFile)((Object)bObject), context);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static TransferStrategy toComp(int n, Mark mark, BComponent bComponent, Context context) {
|
|
BComponentSpace bComponentSpace;
|
|
BSpace bSpace = TransferStrategy.toSpace(mark);
|
|
if (bSpace == (bComponentSpace = bComponent.getComponentSpace())) {
|
|
if (bComponentSpace instanceof RemoteTransferSpace) {
|
|
return new RemoteIntraSpace();
|
|
}
|
|
if (n == 32) {
|
|
return (TransferStrategy)bSpace.fw(113);
|
|
}
|
|
}
|
|
TransferStrategy transferStrategy = null;
|
|
if (bSpace == null) {
|
|
transferStrategy = new CompToComp();
|
|
} else if (bSpace instanceof BComponentSpace) {
|
|
transferStrategy = (TransferStrategy)bSpace.fw(114);
|
|
if (transferStrategy == null) {
|
|
transferStrategy = new CompToComp();
|
|
}
|
|
} else if (bSpace instanceof BFileSpace && (transferStrategy = (TransferStrategy)bSpace.fw(115)) == null) {
|
|
transferStrategy = new FileToComp();
|
|
}
|
|
return transferStrategy;
|
|
}
|
|
|
|
static TransferStrategy toFile(int n, Mark mark, BIFile bIFile, Context context) {
|
|
BSpace bSpace = TransferStrategy.toSpace(mark);
|
|
if (bSpace instanceof BFileSpace) {
|
|
return TransferStrategy.fileToFile(n, mark, bIFile, context);
|
|
}
|
|
if (bSpace instanceof BComponentSpace) {
|
|
return TransferStrategy.componentToFile(n, mark, bIFile, context);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static TransferStrategy fileToFile(int n, Mark mark, BIFile bIFile, Context context) {
|
|
BFileSpace bFileSpace;
|
|
BFileSpace bFileSpace2 = (BFileSpace)TransferStrategy.toSpace(mark);
|
|
if (bFileSpace2 == (bFileSpace = bIFile.getFileSpace())) {
|
|
if (bFileSpace instanceof RemoteTransferSpace) {
|
|
return new RemoteIntraSpace();
|
|
}
|
|
BObject[] bObjectArray = mark.getValues();
|
|
boolean bl = false;
|
|
int n2 = 0;
|
|
while (n2 < bObjectArray.length && !bl) {
|
|
if (bObjectArray[n2] instanceof BIFile && ((BIFile)((Object)bObjectArray[n2])).isDirectory()) {
|
|
bl = true;
|
|
}
|
|
++n2;
|
|
}
|
|
if (n == 32 && !bl) {
|
|
return new IntraFileSpaceMove();
|
|
}
|
|
}
|
|
return new FileToFile();
|
|
}
|
|
|
|
static TransferStrategy componentToFile(int n, Mark mark, BIFile bIFile, Context context) {
|
|
if (bIFile instanceof BDirectory) {
|
|
return new CompToBog();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int getAction() {
|
|
return this.action;
|
|
}
|
|
|
|
public boolean isCopy() {
|
|
boolean bl = false;
|
|
if (this.action == 16) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public boolean isMove() {
|
|
boolean bl = false;
|
|
if (this.action == 32) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public Mark getMark() {
|
|
return this.mark;
|
|
}
|
|
|
|
public BObject getTarget() {
|
|
return this.target;
|
|
}
|
|
|
|
public Context getContext() {
|
|
return this.context;
|
|
}
|
|
|
|
public abstract TransferResult transfer() throws Exception;
|
|
|
|
public BComponent getParameters() {
|
|
return this.params;
|
|
}
|
|
|
|
public BObject getParameter(String string, BObject bObject) {
|
|
if (this.params == null) {
|
|
return bObject;
|
|
}
|
|
BValue bValue = this.params.get(string);
|
|
if (bValue != null) {
|
|
return bValue;
|
|
}
|
|
return bObject;
|
|
}
|
|
|
|
public boolean getParameter(String string, boolean bl) {
|
|
if (this.params == null) {
|
|
return bl;
|
|
}
|
|
BBoolean bBoolean = (BBoolean)this.params.get(string);
|
|
if (bBoolean != null) {
|
|
return bBoolean.getBoolean();
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public int getParameter(String string, int n) {
|
|
if (this.params == null) {
|
|
return n;
|
|
}
|
|
BInteger bInteger = (BInteger)this.params.get(string);
|
|
if (bInteger != null) {
|
|
return bInteger.getInt();
|
|
}
|
|
return n;
|
|
}
|
|
|
|
public String getParameter(String string, String string2) {
|
|
if (this.params == null) {
|
|
return string2;
|
|
}
|
|
BString bString = (BString)this.params.get(string);
|
|
if (bString != null) {
|
|
return bString.getString();
|
|
}
|
|
return string2;
|
|
}
|
|
|
|
public TransferListener getListener() {
|
|
return this.listener;
|
|
}
|
|
|
|
public void setListener(TransferListener transferListener) {
|
|
this.listener = transferListener;
|
|
}
|
|
|
|
public void updateStatus(String string) {
|
|
try {
|
|
if (this.listener != null) {
|
|
this.listener.updateStatus(string);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public static String toString(BObject bObject) {
|
|
try {
|
|
BComponent bComponent;
|
|
if (bObject instanceof BComponent && (bComponent = (BComponent)bObject).isMounted()) {
|
|
return bComponent.toPathString();
|
|
}
|
|
return bObject.getType().toString();
|
|
}
|
|
catch (Exception exception) {
|
|
return "error";
|
|
}
|
|
}
|
|
|
|
public static BSpace toSpace(Mark mark) {
|
|
return TransferStrategy.toSpace(mark.getValues()[0]);
|
|
}
|
|
|
|
public static BSpace toSpace(BObject bObject) {
|
|
if (bObject instanceof BISpaceNode) {
|
|
return ((BISpaceNode)((Object)bObject)).getSpace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static boolean isDebugOn() {
|
|
return log.isTraceOn();
|
|
}
|
|
|
|
public static void debug(String string) {
|
|
System.out.print("> ");
|
|
System.out.println(string);
|
|
}
|
|
|
|
public void dump() {
|
|
TransferStrategy.debug("Transfer: " + this.getClass().getName());
|
|
TransferStrategy.debug(" o action: " + (this.isMove() ? "move" : "copy"));
|
|
TransferStrategy.debug(" o target: " + this.target);
|
|
TransferStrategy.debug(" o mark: " + this.mark);
|
|
TransferStrategy.debug(" o context: " + this.context);
|
|
this.dumpExtra();
|
|
if (this.params == null) {
|
|
TransferStrategy.debug(" o params: null");
|
|
} else {
|
|
TransferStrategy.debug(" o params:");
|
|
Property[] propertyArray = this.params.getPropertiesArray();
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
TransferStrategy.debug(" " + propertyArray[n].getName() + " = " + this.params.get(propertyArray[n]));
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void dumpExtra() {
|
|
}
|
|
}
|
|
|