380 lines
13 KiB
Java
380 lines
13 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.nre.util.Array
|
|
*/
|
|
package javax.baja.naming;
|
|
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.OrdQuery;
|
|
import javax.baja.naming.OrdTarget;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.naming.UnresolvedException;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.virtual.BVirtualGateway;
|
|
import javax.baja.virtual.VirtualPath;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BatchResolve {
|
|
BOrd[] ords;
|
|
Result[] results;
|
|
static /* synthetic */ Class class$javax$baja$naming$BatchResolve$ComponentSpaceItem;
|
|
static /* synthetic */ Class class$javax$baja$naming$BatchResolve$ComponentSpaceGroup;
|
|
static /* synthetic */ Class class$javax$baja$naming$SlotPath;
|
|
|
|
public int size() {
|
|
return this.ords.length;
|
|
}
|
|
|
|
public BOrd getOrd(int n) {
|
|
return this.ords[n];
|
|
}
|
|
|
|
public boolean isResolved(int n) {
|
|
boolean bl = false;
|
|
if (this.results[n].target != null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public Throwable getException(int n) {
|
|
return this.results[n].exception;
|
|
}
|
|
|
|
public OrdTarget getTarget(int n) {
|
|
Result result = this.results[n];
|
|
OrdTarget ordTarget = result.target;
|
|
if (ordTarget != null) {
|
|
return ordTarget;
|
|
}
|
|
if (result.exception instanceof RuntimeException) {
|
|
throw (RuntimeException)result.exception;
|
|
}
|
|
throw new UnresolvedException("" + this.ords[n], result.exception);
|
|
}
|
|
|
|
public BObject get(int n) {
|
|
return this.getTarget(n).get();
|
|
}
|
|
|
|
public OrdTarget[] getTargets() {
|
|
OrdTarget[] ordTargetArray = new OrdTarget[this.results.length];
|
|
int n = 0;
|
|
while (n < ordTargetArray.length) {
|
|
ordTargetArray[n] = this.getTarget(n);
|
|
++n;
|
|
}
|
|
return ordTargetArray;
|
|
}
|
|
|
|
public BObject[] getTargetObjects() {
|
|
OrdTarget[] ordTargetArray = this.getTargets();
|
|
BObject[] bObjectArray = new BObject[ordTargetArray.length];
|
|
int n = 0;
|
|
while (n < bObjectArray.length) {
|
|
bObjectArray[n] = ordTargetArray[n].get();
|
|
++n;
|
|
}
|
|
return bObjectArray;
|
|
}
|
|
|
|
public BComponent[] getTargetComponents() {
|
|
OrdTarget[] ordTargetArray = this.getTargets();
|
|
BComponent[] bComponentArray = new BComponent[ordTargetArray.length];
|
|
int n = 0;
|
|
while (n < bComponentArray.length) {
|
|
bComponentArray[n] = (BComponent)ordTargetArray[n].get();
|
|
++n;
|
|
}
|
|
return bComponentArray;
|
|
}
|
|
|
|
public BatchResolve resolve(BObject bObject) {
|
|
return this.resolve(bObject, null);
|
|
}
|
|
|
|
public BatchResolve resolve(BObject bObject, Context context) {
|
|
try {
|
|
this.resolveComponentSpace(bObject, context);
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
int n = 0;
|
|
while (n < this.ords.length) {
|
|
Result result = this.results[n];
|
|
if (result.target == null && result.exception == null) {
|
|
try {
|
|
result.target = this.ords[n].resolve(bObject, context);
|
|
result.exception = null;
|
|
}
|
|
catch (Throwable throwable) {
|
|
result.target = null;
|
|
result.exception = throwable;
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
private final void resolveComponentSpace(BObject bObject, Context context) {
|
|
Object object;
|
|
Class clazz = class$javax$baja$naming$BatchResolve$ComponentSpaceItem;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$naming$BatchResolve$ComponentSpaceItem = BatchResolve.class("[Ljavax.baja.naming.BatchResolve$ComponentSpaceItem;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
int n = 0;
|
|
while (n < this.ords.length) {
|
|
BOrd bOrd = this.ords[n];
|
|
if ((bOrd.toString().indexOf("slot:") >= 0 || bOrd.toString().indexOf("virtual:") >= 0 || bOrd.toString().indexOf("h:") >= 0) && (object = this.makeComponentSpaceItem(bOrd, bObject)) != null) {
|
|
array.add(object);
|
|
}
|
|
++n;
|
|
}
|
|
if (array.size() == 0) {
|
|
return;
|
|
}
|
|
Class clazz2 = class$javax$baja$naming$BatchResolve$ComponentSpaceGroup;
|
|
if (clazz2 == null) {
|
|
clazz2 = class$javax$baja$naming$BatchResolve$ComponentSpaceGroup = BatchResolve.class("[Ljavax.baja.naming.BatchResolve$ComponentSpaceGroup;", false);
|
|
}
|
|
Array array2 = new Array(clazz2);
|
|
int n2 = 0;
|
|
while (n2 < array.size()) {
|
|
object = (ComponentSpaceItem)array.get(n2);
|
|
BComponentSpace bComponentSpace = ((ComponentSpaceItem)object).space;
|
|
ComponentSpaceGroup componentSpaceGroup = null;
|
|
int n3 = 0;
|
|
while (n3 < array2.size()) {
|
|
ComponentSpaceGroup componentSpaceGroup2 = (ComponentSpaceGroup)array2.get(n3);
|
|
if (componentSpaceGroup2.space == bComponentSpace) {
|
|
componentSpaceGroup = componentSpaceGroup2;
|
|
break;
|
|
}
|
|
++n3;
|
|
}
|
|
if (componentSpaceGroup == null) {
|
|
componentSpaceGroup = new ComponentSpaceGroup(bComponentSpace);
|
|
array2.add((Object)componentSpaceGroup);
|
|
}
|
|
componentSpaceGroup.items.add(object);
|
|
++n2;
|
|
}
|
|
n2 = 0;
|
|
while (n2 < array2.size()) {
|
|
object = (ComponentSpaceGroup)array2.get(n2);
|
|
this.resolveComponentSpaceGroup((ComponentSpaceGroup)object, bObject, context);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
private final ComponentSpaceItem makeComponentSpaceItem(BOrd bOrd, BObject bObject) {
|
|
Object object;
|
|
Object object2;
|
|
ComponentSpaceItem componentSpaceItem = new ComponentSpaceItem(bOrd);
|
|
OrdQuery[] ordQueryArray = bOrd.normalize().parse();
|
|
int n = -1;
|
|
int n2 = 0;
|
|
while (n2 < ordQueryArray.length) {
|
|
object2 = ordQueryArray[n2];
|
|
object = object2.getScheme();
|
|
if (((String)object).equals("virtual")) {
|
|
n = n2;
|
|
componentSpaceItem.slot = object2;
|
|
break;
|
|
}
|
|
if (((String)object).equals("h") && n == -1) {
|
|
n = n2;
|
|
componentSpaceItem.h = object2;
|
|
}
|
|
if (((String)object).equals("slot") && n == -1) {
|
|
n = n2;
|
|
componentSpaceItem.slot = object2;
|
|
}
|
|
++n2;
|
|
}
|
|
if (n == -1) {
|
|
return null;
|
|
}
|
|
BObject bObject2 = null;
|
|
try {
|
|
object2 = BOrd.make(ordQueryArray, 0, n);
|
|
if (!((BOrd)object2).isNull()) {
|
|
bObject2 = ((BOrd)object2).get(bObject);
|
|
}
|
|
}
|
|
catch (Exception exception) {}
|
|
object2 = null;
|
|
if (bObject2 instanceof BComponentSpace) {
|
|
object2 = (BComponentSpace)bObject2;
|
|
} else if (bObject2 instanceof BVirtualGateway) {
|
|
object2 = ((BVirtualGateway)bObject2).getVirtualSpace();
|
|
} else {
|
|
object = BOrd.toSpace(bObject);
|
|
if (object instanceof BComponentSpace) {
|
|
object2 = (BComponentSpace)object;
|
|
}
|
|
}
|
|
if (object2 == null) {
|
|
return null;
|
|
}
|
|
componentSpaceItem.space = object2;
|
|
return componentSpaceItem;
|
|
}
|
|
|
|
private final void resolveComponentSpaceGroup(ComponentSpaceGroup componentSpaceGroup, BObject bObject, Context context) {
|
|
Class clazz;
|
|
SlotPath[] slotPathArray;
|
|
BComponentSpace bComponentSpace = componentSpaceGroup.space;
|
|
ComponentSpaceItem[] componentSpaceItemArray = (ComponentSpaceItem[])componentSpaceGroup.items.trim();
|
|
Class clazz2 = class$javax$baja$naming$BatchResolve$ComponentSpaceItem;
|
|
if (clazz2 == null) {
|
|
clazz2 = class$javax$baja$naming$BatchResolve$ComponentSpaceItem = BatchResolve.class("[Ljavax.baja.naming.BatchResolve$ComponentSpaceItem;", false);
|
|
}
|
|
Array array = new Array(clazz2);
|
|
int n = 0;
|
|
while (n < componentSpaceItemArray.length) {
|
|
slotPathArray = componentSpaceItemArray[n];
|
|
if (slotPathArray.slot != null) {
|
|
slotPathArray.path = this.toSlotPath(slotPathArray.slot, bObject);
|
|
} else {
|
|
array.add((Object)slotPathArray);
|
|
}
|
|
++n;
|
|
}
|
|
if (array.size() > 0) {
|
|
Object[] objectArray = new Object[array.size()];
|
|
int n2 = 0;
|
|
while (n2 < array.size()) {
|
|
ComponentSpaceItem componentSpaceItem = (ComponentSpaceItem)array.get(n2);
|
|
objectArray[n2] = componentSpaceItem.h.getBody();
|
|
++n2;
|
|
}
|
|
slotPathArray = bComponentSpace.handlesToSlotPaths(objectArray);
|
|
int n3 = 0;
|
|
while (n3 < array.size()) {
|
|
ComponentSpaceItem componentSpaceItem = (ComponentSpaceItem)array.get(n3);
|
|
componentSpaceItem.path = slotPathArray[n3];
|
|
++n3;
|
|
}
|
|
}
|
|
if ((clazz = class$javax$baja$naming$SlotPath) == null) {
|
|
clazz = class$javax$baja$naming$SlotPath = BatchResolve.class("[Ljavax.baja.naming.SlotPath;", false);
|
|
}
|
|
Array array2 = new Array(clazz);
|
|
int n4 = 0;
|
|
while (n4 < componentSpaceItemArray.length) {
|
|
ComponentSpaceItem componentSpaceItem = componentSpaceItemArray[n4];
|
|
if (componentSpaceItem.path != null) {
|
|
array2.add((Object)componentSpaceItem.path);
|
|
}
|
|
++n4;
|
|
}
|
|
SlotPath[] slotPathArray2 = (SlotPath[])array2.trim();
|
|
bComponentSpace.fw(104, slotPathArray2, null, null, null);
|
|
}
|
|
|
|
SlotPath toSlotPath(OrdQuery ordQuery, BObject bObject) {
|
|
SlotPath slotPath = null;
|
|
boolean bl = ordQuery.getScheme().equals("virtual");
|
|
slotPath = bl ? new VirtualPath(ordQuery.getBody()) : new SlotPath(ordQuery.getBody());
|
|
if (slotPath.isAbsolute()) {
|
|
return slotPath;
|
|
}
|
|
if (bObject instanceof BComponent && !bl) {
|
|
SlotPath slotPath2 = ((BComponent)bObject).getSlotPath();
|
|
return slotPath2.merge(slotPath);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
public BatchResolve(BOrd[] bOrdArray) {
|
|
this.ords = (BOrd[])bOrdArray.clone();
|
|
this.results = new Result[bOrdArray.length];
|
|
int n = 0;
|
|
while (n < this.results.length) {
|
|
this.results[n] = new Result();
|
|
++n;
|
|
}
|
|
}
|
|
|
|
static class Result {
|
|
OrdTarget target;
|
|
Throwable exception;
|
|
|
|
Result() {
|
|
}
|
|
}
|
|
|
|
static class ComponentSpaceItem {
|
|
BOrd ord;
|
|
OrdQuery h;
|
|
OrdQuery slot;
|
|
BComponentSpace space;
|
|
SlotPath path;
|
|
|
|
ComponentSpaceItem(BOrd bOrd) {
|
|
this.ord = bOrd;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
static class ComponentSpaceGroup {
|
|
BComponentSpace space;
|
|
Array items;
|
|
static /* synthetic */ Class class$javax$baja$naming$BatchResolve$ComponentSpaceItem;
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
Class clazz = class$javax$baja$naming$BatchResolve$ComponentSpaceItem;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$naming$BatchResolve$ComponentSpaceItem = ComponentSpaceGroup.class("[Ljavax.baja.naming.BatchResolve$ComponentSpaceItem;", false);
|
|
}
|
|
this.items = new Array(clazz);
|
|
}
|
|
|
|
ComponentSpaceGroup(BComponentSpace bComponentSpace) {
|
|
this.this();
|
|
this.space = bComponentSpace;
|
|
}
|
|
}
|
|
}
|
|
|