903 lines
29 KiB
Java
903 lines
29 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.xml.XElem
|
|
* javax.baja.xml.XException
|
|
* javax.baja.xml.XParser
|
|
*/
|
|
package javax.baja.io;
|
|
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.module.NModule;
|
|
import com.tridium.sys.schema.ComponentSlotMap;
|
|
import com.tridium.util.SimpleFactory;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.EOFException;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import javax.baja.category.BCategoryMask;
|
|
import javax.baja.file.BIFile;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BDouble;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BFloat;
|
|
import javax.baja.sys.BInteger;
|
|
import javax.baja.sys.BLong;
|
|
import javax.baja.sys.BModule;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BSimple;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Flags;
|
|
import javax.baja.sys.ModuleException;
|
|
import javax.baja.sys.ModuleNotFoundException;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.sys.TypeNotFoundException;
|
|
import javax.baja.xml.XElem;
|
|
import javax.baja.xml.XException;
|
|
import javax.baja.xml.XParser;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class ValueDocDecoder {
|
|
private static final Map typeSwapMap = new HashMap();
|
|
private static final boolean decodeTypeSwap;
|
|
private SimpleFactory simpleFactory;
|
|
protected final IDecoderPlugin plugin;
|
|
private Context context;
|
|
|
|
public static final BValue unmarshal(String string) throws Exception {
|
|
return BogDecoderPlugin.unmarshal(string);
|
|
}
|
|
|
|
public static final BValue unmarshal(String string, ITypeResolver iTypeResolver) throws Exception {
|
|
return BogDecoderPlugin.unmarshal(string, iTypeResolver);
|
|
}
|
|
|
|
public final ITypeResolver getTypeResolver() {
|
|
return this.plugin.getTypeResolver();
|
|
}
|
|
|
|
public final void setTypeResolver(ITypeResolver iTypeResolver) {
|
|
this.plugin.setTypeResolver(iTypeResolver);
|
|
}
|
|
|
|
public BValue decodeDocument() throws Exception {
|
|
return this.decodeDocument(true);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
*/
|
|
public BValue decodeDocument(boolean bl) throws Exception {
|
|
try {
|
|
BValue bValue = this.plugin.decodeDocument(this);
|
|
Object var3_3 = null;
|
|
if (bl) {
|
|
this.plugin.close();
|
|
}
|
|
return bValue;
|
|
}
|
|
catch (Throwable throwable) {
|
|
block3: {
|
|
Object var3_4 = null;
|
|
if (!bl) break block3;
|
|
this.plugin.close();
|
|
}
|
|
throw throwable;
|
|
}
|
|
}
|
|
|
|
public BValue decode() throws Exception {
|
|
return this.parseSlot(null, true);
|
|
}
|
|
|
|
public final IDecoderPlugin getPlugin() {
|
|
return this.plugin;
|
|
}
|
|
|
|
public final IElement elem() {
|
|
return this.plugin.elem();
|
|
}
|
|
|
|
public final int next() throws Exception {
|
|
return this.plugin.next();
|
|
}
|
|
|
|
public final void skip() throws Exception {
|
|
this.plugin.skip();
|
|
}
|
|
|
|
public final void skip(int n) throws Exception {
|
|
this.plugin.skip(n);
|
|
}
|
|
|
|
public final int type() {
|
|
return this.plugin.type();
|
|
}
|
|
|
|
public final int line() {
|
|
return this.plugin.line();
|
|
}
|
|
|
|
public final int column() {
|
|
return this.plugin.column();
|
|
}
|
|
|
|
public final void close() {
|
|
this.plugin.close();
|
|
}
|
|
|
|
public final int depth() {
|
|
return this.plugin.depth();
|
|
}
|
|
|
|
public final String getEncoding() throws IOException {
|
|
return this.plugin.getEncoding();
|
|
}
|
|
|
|
public final boolean isZipped() throws IOException {
|
|
return this.plugin.isZipped();
|
|
}
|
|
|
|
public final IElement parse() throws Exception {
|
|
return this.plugin.parse();
|
|
}
|
|
|
|
public IElement parse(boolean bl) throws Exception {
|
|
return this.plugin.parse(bl);
|
|
}
|
|
|
|
public final IElement parseCurrent() throws Exception {
|
|
return this.plugin.parseCurrent();
|
|
}
|
|
|
|
public final IElement parseCurrent(boolean bl) throws Exception {
|
|
return this.plugin.parseCurrent(bl);
|
|
}
|
|
|
|
public final RuntimeException err(String string, Throwable throwable) {
|
|
return this.plugin.err(string, throwable);
|
|
}
|
|
|
|
public final RuntimeException err(String string) {
|
|
return this.plugin.err(string);
|
|
}
|
|
|
|
public final void warningAndSkip(String string) throws RuntimeException {
|
|
this.plugin.warningAndSkip(string);
|
|
}
|
|
|
|
public final void warning(String string) {
|
|
this.plugin.warning(string);
|
|
}
|
|
|
|
public final Log getLog() {
|
|
return this.plugin.getLog();
|
|
}
|
|
|
|
public final void setLog(Log log) {
|
|
this.plugin.setLog(log);
|
|
}
|
|
|
|
public final int getWarningCount() {
|
|
return this.plugin.getWarningCount();
|
|
}
|
|
|
|
protected void decodingComponent(BComponent bComponent) throws Exception {
|
|
this.plugin.warningAndSkip("Unknown element <" + this.plugin.elem().name() + "> for decodingComponent");
|
|
}
|
|
|
|
private final void parseSlots(BObject bObject) throws Exception {
|
|
while (true) {
|
|
int n;
|
|
if ((n = this.next()) == -1) {
|
|
throw new EOFException();
|
|
}
|
|
if (n == 2) {
|
|
return;
|
|
}
|
|
if (n != 1) {
|
|
throw this.err("Expected element start");
|
|
}
|
|
this.parseSlot((BComplex)bObject, false);
|
|
}
|
|
}
|
|
|
|
private final BValue parseSlot(BComplex bComplex, boolean bl) throws Exception {
|
|
Object object;
|
|
Object object2;
|
|
if (this.type() != 1) {
|
|
throw this.err("Expected element start (" + this.type() + ')');
|
|
}
|
|
IElement iElement = this.plugin.elem();
|
|
String string = iElement.name().intern();
|
|
if (string != "p" && string != "a" && string != "t") {
|
|
if (bComplex instanceof BComponent) {
|
|
this.decodingComponent((BComponent)bComplex);
|
|
} else {
|
|
this.plugin.warningAndSkip("Unknown element <" + string + '>');
|
|
}
|
|
if (bl) {
|
|
throw this.err("Unknown element <" + string + '>');
|
|
}
|
|
return null;
|
|
}
|
|
String string2 = null;
|
|
String string3 = null;
|
|
Object object3 = null;
|
|
Object object4 = null;
|
|
String string4 = null;
|
|
Object object5 = null;
|
|
BFacets bFacets = BFacets.NULL;
|
|
Object object6 = null;
|
|
boolean bl2 = false;
|
|
int n = iElement.attrSize();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
object2 = iElement.attrName(n2);
|
|
object = iElement.attrValue(n2);
|
|
if (object2 == "n") {
|
|
string2 = object;
|
|
} else if (object2 == "h") {
|
|
string3 = object;
|
|
} else if (object2 == "v") {
|
|
string4 = object;
|
|
} else if (object2 == "t") {
|
|
object4 = object;
|
|
} else if (object2 == "m") {
|
|
object3 = object;
|
|
} else if (object2 == "f") {
|
|
object5 = object;
|
|
} else if (object2 == "x") {
|
|
bFacets = this.decodeFacets((String)object);
|
|
} else if (object2 == "c") {
|
|
object6 = object;
|
|
} else if (((String)object2).equals("stub")) {
|
|
bl2 = ((String)object).equals("true");
|
|
}
|
|
++n2;
|
|
}
|
|
n2 = this.decodeFlags((String)object5);
|
|
if (object3 != null && this.plugin.getTypeResolver().loadModule(this, bComplex, string2, (String)object3, (String)object4) == null) {
|
|
try {
|
|
this.plugin.skip();
|
|
}
|
|
catch (RuntimeException runtimeException) {
|
|
this.plugin.warning("Missing module " + (String)(((String)object3).indexOf(61) != -1 ? ((String)object3).substring(((String)object3).indexOf(61) + 1) : object3));
|
|
throw runtimeException;
|
|
}
|
|
catch (Exception exception) {
|
|
this.plugin.warning("Missing module " + (String)object3);
|
|
throw this.plugin.err("Missing module " + (String)(((String)object3).indexOf(61) != -1 ? ((String)object3).substring(((String)object3).indexOf(61) + 1) : object3));
|
|
}
|
|
if (bl) {
|
|
throw this.plugin.err("Missing module " + (String)(((String)object3).indexOf(61) != -1 ? ((String)object3).substring(((String)object3).indexOf(61) + 1) : object3));
|
|
}
|
|
if (this.plugin.getLog().isTraceOn()) {
|
|
this.plugin.getLog().trace("Missing module: " + (String)object3);
|
|
}
|
|
}
|
|
object2 = null;
|
|
if (bComplex != null) {
|
|
if (string2 == null) {
|
|
throw this.plugin.err("Missing \"n\" name attribute");
|
|
}
|
|
object2 = bComplex.getSlot(string2);
|
|
}
|
|
if (object2 != null) {
|
|
if (object5 != null) {
|
|
bComplex.setFlags((Slot)object2, n2, Context.decoding);
|
|
}
|
|
if (!object2.isProperty()) {
|
|
this.plugin.skip();
|
|
return null;
|
|
}
|
|
} else {
|
|
if (string == "a") {
|
|
this.plugin.warningAndSkip("Missing frozen action: " + string2);
|
|
return null;
|
|
}
|
|
if (string == "t") {
|
|
this.plugin.warningAndSkip("Missing frozen topic: " + string2);
|
|
return null;
|
|
}
|
|
}
|
|
if (this.decodePrimitive(bComplex, (Property)(object = (Property)object2), string4)) {
|
|
if (bl) {
|
|
throw this.err("Incountered unexpected primitive");
|
|
}
|
|
return null;
|
|
}
|
|
BValue bValue = this.plugin.getTypeResolver().newInstance(this, bComplex, string2, (Property)object, (String)object4);
|
|
if (bValue == null) {
|
|
if (bl) {
|
|
throw this.err("Unable to instantiate " + (String)(((String)object4).indexOf(58) != -1 ? ((String)object4).substring(((String)object4).indexOf(58) + 1) : object4));
|
|
}
|
|
return null;
|
|
}
|
|
if (bValue.isSimple() && string4 != null) {
|
|
if (this.isTypeBlackListed(bValue.getType())) {
|
|
throw this.err("Cannot decode blacklisted Simple Type: " + bValue.getType());
|
|
}
|
|
bValue = this.decodeSimple(bValue, string4);
|
|
}
|
|
if (bValue.isComponent()) {
|
|
((ComponentSlotMap)bValue.fw(1)).setHandle(string3);
|
|
if (!bl2) {
|
|
((ComponentSlotMap)bValue.fw(1)).setBrokerPropsLoaded(true);
|
|
}
|
|
if (object6 != null) {
|
|
((BComponent)bValue).setCategoryMask(BCategoryMask.make((String)object6), Context.decoding);
|
|
}
|
|
}
|
|
if (bComplex != null) {
|
|
if (object != null) {
|
|
if (!object.isFrozen()) {
|
|
throw this.plugin.err("Duplicate slot " + bComplex.getType().getTypeName() + '.' + string2);
|
|
}
|
|
try {
|
|
bComplex.set((Property)object, bValue, Context.decoding);
|
|
}
|
|
catch (Exception exception) {
|
|
this.plugin.warningAndSkip("Cannot set property " + bComplex.getType().getTypeName() + '.' + string2 + ": " + exception);
|
|
}
|
|
} else if (bComplex.isComponent()) {
|
|
bComplex.asComponent().add(string2, bValue, n2, bFacets, Context.decoding);
|
|
} else {
|
|
this.plugin.warningAndSkip("Missing slot " + bComplex.getType().getTypeName() + '.' + string2);
|
|
}
|
|
}
|
|
this.parseSlots(bValue);
|
|
return bValue;
|
|
}
|
|
|
|
private final boolean decodePrimitive(BComplex bComplex, Property property, String string) throws Exception {
|
|
if (property == null || string == null) {
|
|
return false;
|
|
}
|
|
if (property.getTypeAccess() == 7) {
|
|
return false;
|
|
}
|
|
switch (property.getTypeAccess()) {
|
|
case 0: {
|
|
bComplex.setBoolean(property, BBoolean.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComplex.setInt(property, BInteger.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComplex.setLong(property, BLong.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComplex.setFloat(property, BFloat.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 5: {
|
|
bComplex.setDouble(property, BDouble.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 6: {
|
|
bComplex.setString(property, string, Context.decoding);
|
|
break;
|
|
}
|
|
default: {
|
|
throw new IllegalStateException("" + property.getTypeAccess());
|
|
}
|
|
}
|
|
int n = this.next();
|
|
if (n != 2) {
|
|
throw this.err("Expecting end of p element for simple property " + property.getName());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected BSimple decodeSimple(BObject bObject, String string) {
|
|
try {
|
|
return this.simpleFactory.make(bObject.getType(), string, this.context);
|
|
}
|
|
catch (Exception exception) {
|
|
throw this.plugin.err("Invalid " + bObject.getType().getTypeName() + ": '" + string + '\'', exception);
|
|
}
|
|
}
|
|
|
|
private final int decodeFlags(String string) {
|
|
if (string == null) {
|
|
return 0;
|
|
}
|
|
return Flags.decodeFromString(string);
|
|
}
|
|
|
|
private final BFacets decodeFacets(String string) {
|
|
try {
|
|
if (string == null) {
|
|
return BFacets.NULL;
|
|
}
|
|
return (BFacets)this.simpleFactory.make(BFacets.TYPE, string, this.context);
|
|
}
|
|
catch (Exception exception) {
|
|
throw this.plugin.err("Invalid facets " + string, exception);
|
|
}
|
|
}
|
|
|
|
public boolean isTypeBlackListed(Type type) {
|
|
return false;
|
|
}
|
|
|
|
static final BValue typeResolverNewInstance(NModule nModule, String string) {
|
|
Type type;
|
|
try {
|
|
type = nModule.getType(string);
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
if (decodeTypeSwap) {
|
|
String string2 = (String)typeSwapMap.get(nModule.getModuleName() + ':' + string);
|
|
if (string2 != null) {
|
|
type = Sys.getType(string2);
|
|
}
|
|
throw typeNotFoundException;
|
|
}
|
|
throw typeNotFoundException;
|
|
}
|
|
return (BValue)type.getInstance();
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.simpleFactory = new SimpleFactory();
|
|
this.context = null;
|
|
}
|
|
|
|
public ValueDocDecoder(IDecoderPlugin iDecoderPlugin) throws Exception {
|
|
this.this();
|
|
this.plugin = iDecoderPlugin;
|
|
}
|
|
|
|
public ValueDocDecoder(BOrd bOrd) throws Exception {
|
|
this(new BogDecoderPlugin(bOrd));
|
|
}
|
|
|
|
public ValueDocDecoder(BIFile bIFile) throws Exception {
|
|
this(new BogDecoderPlugin(bIFile));
|
|
}
|
|
|
|
public ValueDocDecoder(File file) throws Exception {
|
|
this(new BogDecoderPlugin(file));
|
|
}
|
|
|
|
public ValueDocDecoder(InputStream inputStream) throws Exception {
|
|
this(new BogDecoderPlugin(inputStream));
|
|
}
|
|
|
|
static {
|
|
typeSwapMap.put("niagaraDriver:NiagaraVirtualGateway", "niagaraDriver:NiagaraVirtualDeviceExt");
|
|
decodeTypeSwap = System.getProperty("niagara.decodeTypeSwap", "true").equals("true");
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public static final class BogDecoderPlugin
|
|
implements IDecoderPlugin {
|
|
public static final ITypeResolver defaultTypeResolver = new BogTypeResolver();
|
|
private static final Log defaultLog = Log.getLog("sys.xml");
|
|
private final XParser parser;
|
|
private HashMap modules;
|
|
private ITypeResolver typeResolver;
|
|
private Log log;
|
|
private int warningCount;
|
|
|
|
public final BValue decodeDocument(ValueDocDecoder valueDocDecoder) throws Exception {
|
|
this.next();
|
|
IElement iElement = this.elem();
|
|
if (!iElement.name().equals("bajaObjectGraph")) {
|
|
throw this.err("Root element must be \"bajaObjectGraph\"");
|
|
}
|
|
String string = iElement.get("version");
|
|
if (!string.equals("1.0") && !string.equals("1.1")) {
|
|
throw this.err("Only versions 1.0 and 1.1 are supported");
|
|
}
|
|
this.next();
|
|
BValue bValue = valueDocDecoder.decode();
|
|
this.next();
|
|
if (this.type() != 2 || !this.elem().name().equals("bajaObjectGraph")) {
|
|
throw this.err("Expected end tag for \"bajaObjectGraph\"");
|
|
}
|
|
return bValue;
|
|
}
|
|
|
|
public final int next() throws Exception {
|
|
return this.parser.next();
|
|
}
|
|
|
|
public final IElement elem() {
|
|
return BogElement.make(this.parser.elem());
|
|
}
|
|
|
|
public final void skip() throws Exception {
|
|
this.parser.skip();
|
|
}
|
|
|
|
public final void skip(int n) throws Exception {
|
|
this.parser.skip(n);
|
|
}
|
|
|
|
public final int type() {
|
|
return this.parser.type();
|
|
}
|
|
|
|
public final int line() {
|
|
return this.parser.line();
|
|
}
|
|
|
|
public final int column() {
|
|
return this.parser.column();
|
|
}
|
|
|
|
public final void close() {
|
|
this.parser.close();
|
|
}
|
|
|
|
public final int depth() {
|
|
return this.parser.depth();
|
|
}
|
|
|
|
public final String getEncoding() throws IOException {
|
|
return this.parser.getEncoding();
|
|
}
|
|
|
|
public final boolean isZipped() throws IOException {
|
|
return this.parser.isZipped();
|
|
}
|
|
|
|
public final IElement parse() throws Exception {
|
|
return BogElement.make(this.parser.parse());
|
|
}
|
|
|
|
public final IElement parse(boolean bl) throws Exception {
|
|
return BogElement.make(this.parser.parse(bl));
|
|
}
|
|
|
|
public final IElement parseCurrent() throws Exception {
|
|
return BogElement.make(this.parser.parseCurrent());
|
|
}
|
|
|
|
public final IElement parseCurrent(boolean bl) throws Exception {
|
|
return BogElement.make(this.parser.parseCurrent(bl));
|
|
}
|
|
|
|
public final ITypeResolver getTypeResolver() {
|
|
return this.typeResolver;
|
|
}
|
|
|
|
public final void setTypeResolver(ITypeResolver iTypeResolver) {
|
|
this.typeResolver = iTypeResolver == null ? defaultTypeResolver : iTypeResolver;
|
|
}
|
|
|
|
public final RuntimeException err(String string, Throwable throwable) {
|
|
return new XException(string, this.parser.line(), this.parser.column(), throwable);
|
|
}
|
|
|
|
public final RuntimeException err(String string) {
|
|
return new XException(string, this.parser.line(), this.parser.column());
|
|
}
|
|
|
|
public final void warningAndSkip(String string) throws RuntimeException {
|
|
this.warning(string);
|
|
try {
|
|
this.skip();
|
|
}
|
|
catch (XException xException) {
|
|
throw xException;
|
|
}
|
|
catch (Exception exception) {
|
|
throw new XException((Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public final void warning(String string) throws RuntimeException {
|
|
this.log.warning(string + " [" + this.parser.line() + ':' + this.parser.column() + ']');
|
|
++this.warningCount;
|
|
}
|
|
|
|
public final Log getLog() {
|
|
return this.log;
|
|
}
|
|
|
|
public final void setLog(Log log) {
|
|
this.log = log;
|
|
}
|
|
|
|
public final int getWarningCount() {
|
|
return this.warningCount;
|
|
}
|
|
|
|
public final XParser getXmlParser() {
|
|
return this.parser;
|
|
}
|
|
|
|
public static final BValue unmarshal(String string) throws Exception {
|
|
BogDecoderPlugin bogDecoderPlugin = new BogDecoderPlugin(new ByteArrayInputStream(string.getBytes()));
|
|
ValueDocDecoder valueDocDecoder = new ValueDocDecoder(bogDecoderPlugin);
|
|
valueDocDecoder.plugin.next();
|
|
return valueDocDecoder.decode();
|
|
}
|
|
|
|
public static final BValue unmarshal(String string, ITypeResolver iTypeResolver) throws Exception {
|
|
BogDecoderPlugin bogDecoderPlugin = new BogDecoderPlugin(new ByteArrayInputStream(string.getBytes()));
|
|
ValueDocDecoder valueDocDecoder = new ValueDocDecoder(bogDecoderPlugin);
|
|
valueDocDecoder.plugin.setTypeResolver(iTypeResolver);
|
|
valueDocDecoder.plugin.next();
|
|
return valueDocDecoder.decode();
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.modules = new HashMap();
|
|
this.typeResolver = new BogTypeResolver();
|
|
this.log = defaultLog;
|
|
}
|
|
|
|
public BogDecoderPlugin(InputStream inputStream) throws Exception {
|
|
this.this();
|
|
this.parser = XParser.make((InputStream)inputStream);
|
|
}
|
|
|
|
public BogDecoderPlugin(BOrd bOrd) throws Exception {
|
|
this((BIFile)((Object)bOrd.resolve().get()));
|
|
}
|
|
|
|
public BogDecoderPlugin(BIFile bIFile) throws Exception {
|
|
this(new BufferedInputStream(bIFile.getInputStream()));
|
|
}
|
|
|
|
public BogDecoderPlugin(File file) throws Exception {
|
|
this(new BufferedInputStream(new FileInputStream(file)));
|
|
}
|
|
}
|
|
|
|
public static interface IDecoderPlugin {
|
|
public BValue decodeDocument(ValueDocDecoder var1) throws Exception;
|
|
|
|
public int next() throws Exception;
|
|
|
|
public IElement elem();
|
|
|
|
public void skip() throws Exception;
|
|
|
|
public void skip(int var1) throws Exception;
|
|
|
|
public int type();
|
|
|
|
public int line();
|
|
|
|
public int column();
|
|
|
|
public void close();
|
|
|
|
public int depth();
|
|
|
|
public String getEncoding() throws IOException;
|
|
|
|
public boolean isZipped() throws IOException;
|
|
|
|
public IElement parse() throws Exception;
|
|
|
|
public IElement parse(boolean var1) throws Exception;
|
|
|
|
public IElement parseCurrent() throws Exception;
|
|
|
|
public IElement parseCurrent(boolean var1) throws Exception;
|
|
|
|
public ITypeResolver getTypeResolver();
|
|
|
|
public void setTypeResolver(ITypeResolver var1);
|
|
|
|
public RuntimeException err(String var1, Throwable var2);
|
|
|
|
public RuntimeException err(String var1);
|
|
|
|
public void warningAndSkip(String var1) throws RuntimeException;
|
|
|
|
public void warning(String var1);
|
|
|
|
public Log getLog();
|
|
|
|
public void setLog(Log var1);
|
|
|
|
public int getWarningCount();
|
|
}
|
|
|
|
public static interface IElement {
|
|
public String name();
|
|
|
|
public String get(String var1);
|
|
|
|
public String get(String var1, String var2);
|
|
|
|
public int geti(String var1);
|
|
|
|
public int geti(String var1, int var2);
|
|
|
|
public double getd(String var1);
|
|
|
|
public double getd(String var1, double var2);
|
|
|
|
public float getf(String var1);
|
|
|
|
public float getf(String var1, float var2);
|
|
|
|
public long getl(String var1);
|
|
|
|
public long getl(String var1, long var2);
|
|
|
|
public int attrSize();
|
|
|
|
public String attrName(int var1);
|
|
|
|
public String attrValue(int var1);
|
|
|
|
public IElement copy();
|
|
}
|
|
|
|
public static interface ITypeResolver {
|
|
public BModule loadModule(ValueDocDecoder var1, BComplex var2, String var3, String var4, String var5);
|
|
|
|
public BValue newInstance(ValueDocDecoder var1, BComplex var2, String var3, Property var4, String var5);
|
|
}
|
|
|
|
public static class BogTypeResolver
|
|
implements ITypeResolver {
|
|
public BModule loadModule(ValueDocDecoder valueDocDecoder, BComplex bComplex, String string, String string2, String string3) {
|
|
try {
|
|
int n = string2.indexOf(61);
|
|
String string4 = string2.substring(0, n).trim();
|
|
String string5 = string2.substring(n + 1).trim();
|
|
NModule nModule = Nre.moduleManager.loadModule(string5);
|
|
this.getModuleMap(valueDocDecoder).put(string4, nModule);
|
|
return nModule.bmodule();
|
|
}
|
|
catch (ModuleException moduleException) {
|
|
throw valueDocDecoder.plugin.err("Cannot load module '" + string2 + '\'', moduleException);
|
|
}
|
|
catch (Exception exception) {
|
|
throw valueDocDecoder.plugin.err("Invalid module attribute '" + string2 + '\'');
|
|
}
|
|
}
|
|
|
|
public BValue newInstance(ValueDocDecoder valueDocDecoder, BComplex bComplex, String string, Property property, String string2) {
|
|
if (string2 == null) {
|
|
if (property != null) {
|
|
return property.getDefaultValue();
|
|
}
|
|
valueDocDecoder.plugin.warningAndSkip("Missing frozen property: " + string);
|
|
return null;
|
|
}
|
|
try {
|
|
int n = string2.indexOf(58);
|
|
if (n <= 0) {
|
|
throw valueDocDecoder.plugin.err("Invalid typespec '" + string2 + '\'');
|
|
}
|
|
String string3 = string2.substring(0, n);
|
|
String string4 = string2.substring(n + 1);
|
|
NModule nModule = (NModule)this.getModuleMap(valueDocDecoder).get(string3);
|
|
if (nModule == null) {
|
|
throw valueDocDecoder.plugin.err("Undeclared module symbol: " + string3, new ModuleNotFoundException(string3));
|
|
}
|
|
return ValueDocDecoder.typeResolverNewInstance(nModule, string4);
|
|
}
|
|
catch (XException xException) {
|
|
throw xException;
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
valueDocDecoder.plugin.warningAndSkip("Type \"" + typeNotFoundException.getMessage() + "\" not found: " + string);
|
|
return null;
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw valueDocDecoder.plugin.err("Cannot instantiate type '" + string2 + '\'', throwable);
|
|
}
|
|
}
|
|
|
|
public Map getModuleMap(ValueDocDecoder valueDocDecoder) {
|
|
return ((BogDecoderPlugin)valueDocDecoder.plugin).modules;
|
|
}
|
|
}
|
|
|
|
public static final class BogElement
|
|
implements IElement {
|
|
private XElem elem;
|
|
|
|
public static final BogElement make(XElem xElem) {
|
|
return xElem == null ? null : new BogElement(xElem);
|
|
}
|
|
|
|
public final String name() {
|
|
return this.elem.name();
|
|
}
|
|
|
|
public final String get(String string) {
|
|
return this.elem.get(string);
|
|
}
|
|
|
|
public final String get(String string, String string2) {
|
|
return this.elem.get(string, string2);
|
|
}
|
|
|
|
public final int geti(String string) {
|
|
return this.elem.geti(string);
|
|
}
|
|
|
|
public final int geti(String string, int n) {
|
|
return this.elem.geti(string, n);
|
|
}
|
|
|
|
public final double getd(String string) {
|
|
return this.elem.getd(string);
|
|
}
|
|
|
|
public final double getd(String string, double d) {
|
|
return this.elem.getd(string, d);
|
|
}
|
|
|
|
public final float getf(String string) {
|
|
return this.elem.getf(string);
|
|
}
|
|
|
|
public final float getf(String string, float f) {
|
|
return this.elem.getf(string, f);
|
|
}
|
|
|
|
public final long getl(String string) {
|
|
return this.elem.getl(string);
|
|
}
|
|
|
|
public final long getl(String string, long l) {
|
|
return this.elem.getl(string, l);
|
|
}
|
|
|
|
public final int attrSize() {
|
|
return this.elem.attrSize();
|
|
}
|
|
|
|
public final String attrName(int n) {
|
|
return this.elem.attrName(n);
|
|
}
|
|
|
|
public final String attrValue(int n) {
|
|
return this.elem.attrValue(n);
|
|
}
|
|
|
|
public final IElement copy() {
|
|
return BogElement.make(this.elem.copy());
|
|
}
|
|
|
|
public final String toString() {
|
|
return this.elem.toString();
|
|
}
|
|
|
|
public final XElem getXmlElement() {
|
|
return this.elem;
|
|
}
|
|
|
|
private BogElement(XElem xElem) {
|
|
this.elem = xElem;
|
|
}
|
|
}
|
|
}
|
|
|