663 lines
24 KiB
Java
663 lines
24 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.nre.util.SortUtil
|
|
* javax.baja.nre.util.TextUtil
|
|
*/
|
|
package com.tridium.sys.registry;
|
|
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.registry.Builder;
|
|
import com.tridium.sys.registry.NAdapterInfo;
|
|
import com.tridium.sys.registry.NAgentInfo;
|
|
import com.tridium.sys.registry.NAgentList;
|
|
import com.tridium.sys.registry.NDependencyInfo;
|
|
import com.tridium.sys.registry.NLexiconInfo;
|
|
import com.tridium.sys.registry.NModuleInfo;
|
|
import com.tridium.sys.registry.NTypeInfo;
|
|
import com.tridium.util.ArrayUtil;
|
|
import java.io.BufferedOutputStream;
|
|
import java.io.DataInputStream;
|
|
import java.io.DataOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import javax.baja.agent.AgentInfo;
|
|
import javax.baja.agent.AgentList;
|
|
import javax.baja.agent.BIAgent;
|
|
import javax.baja.naming.UnknownSchemeException;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.nre.util.SortUtil;
|
|
import javax.baja.nre.util.TextUtil;
|
|
import javax.baja.registry.LexiconInfo;
|
|
import javax.baja.registry.ModuleInfo;
|
|
import javax.baja.registry.RegistryException;
|
|
import javax.baja.registry.TypeInfo;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BFrozenEnum;
|
|
import javax.baja.sys.BModule;
|
|
import javax.baja.sys.ModuleNotFoundException;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.sys.TypeNotFoundException;
|
|
import javax.baja.util.BTypeSpec;
|
|
import javax.baja.util.Lexicon;
|
|
import javax.baja.util.Version;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class RegistryDatabase {
|
|
static String[] noDefs = new String[0];
|
|
public static final long magic = 7958534985112118370L;
|
|
public static final int version = 3;
|
|
NModuleInfo[] modules;
|
|
HashMap modulesByName;
|
|
NTypeInfo[] types;
|
|
HashMap typesBySpec;
|
|
HashMap defs;
|
|
String[] fileExts;
|
|
HashMap typesByFileExt;
|
|
String[] ordSchemes;
|
|
HashMap lexicons;
|
|
HashMap typesByOrdScheme;
|
|
NAdapterInfo[] adapters;
|
|
static /* synthetic */ Class class$com$tridium$sys$registry$NAgentInfo;
|
|
|
|
public ModuleInfo[] getModules() {
|
|
return (ModuleInfo[])this.modules.clone();
|
|
}
|
|
|
|
public ModuleInfo getModule(String string) {
|
|
ModuleInfo moduleInfo = (ModuleInfo)this.modulesByName.get(string);
|
|
if (moduleInfo == null) {
|
|
throw new ModuleNotFoundException(string);
|
|
}
|
|
return moduleInfo;
|
|
}
|
|
|
|
public TypeInfo[] getTypes() {
|
|
return (TypeInfo[])this.types.clone();
|
|
}
|
|
|
|
public TypeInfo[] getTypes(TypeInfo typeInfo, boolean bl) {
|
|
ArrayList<TypeInfo> arrayList = new ArrayList<TypeInfo>();
|
|
ModuleInfo[] moduleInfoArray = this.getModules();
|
|
int n = 0;
|
|
while (n < moduleInfoArray.length) {
|
|
TypeInfo[] typeInfoArray = moduleInfoArray[n].getTypes();
|
|
int n2 = 0;
|
|
while (n2 < typeInfoArray.length) {
|
|
TypeInfo typeInfo2 = typeInfoArray[n2];
|
|
if (!(bl && typeInfo2.isAbstract() || !typeInfo2.is(typeInfo))) {
|
|
arrayList.add(typeInfo2);
|
|
}
|
|
++n2;
|
|
}
|
|
++n;
|
|
}
|
|
return arrayList.toArray(new TypeInfo[arrayList.size()]);
|
|
}
|
|
|
|
public TypeInfo getType(String string) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesBySpec.get(string);
|
|
if (nTypeInfo == null) {
|
|
throw new TypeNotFoundException(string);
|
|
}
|
|
return nTypeInfo;
|
|
}
|
|
|
|
public String[] getDefs() {
|
|
return this.defs.keySet().toArray(new String[this.defs.size()]);
|
|
}
|
|
|
|
public String[] getDefs(String string) {
|
|
String[] stringArray = (String[])this.defs.get(string);
|
|
if (stringArray == null) {
|
|
return noDefs;
|
|
}
|
|
return (String[])stringArray.clone();
|
|
}
|
|
|
|
public String getDef(String string, String string2) {
|
|
String[] stringArray = (String[])this.defs.get(string);
|
|
if (stringArray == null) {
|
|
return string2;
|
|
}
|
|
return stringArray[0];
|
|
}
|
|
|
|
public AgentList getAgents(TypeInfo typeInfo) {
|
|
return typeInfo.getAgents();
|
|
}
|
|
|
|
public AgentList getSpecificAgents(TypeInfo typeInfo) {
|
|
NAgentList nAgentList = new NAgentList();
|
|
NTypeInfo[] nTypeInfoArray = ((NTypeInfo)typeInfo).agents;
|
|
int n = 0;
|
|
while (n < nTypeInfoArray.length) {
|
|
nAgentList.add(nTypeInfoArray[n].getAgentInfo());
|
|
++n;
|
|
}
|
|
return nAgentList;
|
|
}
|
|
|
|
public boolean isAgent(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
NTypeInfo[] nTypeInfoArray = ((NTypeInfo)typeInfo2).is;
|
|
int n = nTypeInfoArray.length - 1;
|
|
while (n >= 0) {
|
|
NTypeInfo[] nTypeInfoArray2 = nTypeInfoArray[n].agents;
|
|
int n2 = 0;
|
|
while (n2 < nTypeInfoArray2.length) {
|
|
if (nTypeInfoArray2[n2].getAgentInfo().getAgentType() == typeInfo) {
|
|
return true;
|
|
}
|
|
++n2;
|
|
}
|
|
--n;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isSpecificAgent(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
NTypeInfo[] nTypeInfoArray = ((NTypeInfo)typeInfo2).agents;
|
|
int n = 0;
|
|
while (n < nTypeInfoArray.length) {
|
|
if (nTypeInfoArray[n] == typeInfo) {
|
|
return true;
|
|
}
|
|
++n;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public TypeInfo[] getAdapters(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
ArrayList<NTypeInfo> arrayList = new ArrayList<NTypeInfo>();
|
|
NAdapterInfo[] nAdapterInfoArray = this.adapters;
|
|
int n = nAdapterInfoArray.length;
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
if (nAdapterInfoArray[n2].isMatch(typeInfo, typeInfo2)) {
|
|
arrayList.add(nAdapterInfoArray[n2].type);
|
|
}
|
|
++n2;
|
|
}
|
|
return arrayList.toArray(new TypeInfo[arrayList.size()]);
|
|
}
|
|
|
|
public String[] getFileExtensions() {
|
|
return (String[])this.fileExts.clone();
|
|
}
|
|
|
|
public String[] getFileExtensions(TypeInfo typeInfo) {
|
|
ArrayList<String> arrayList = new ArrayList<String>();
|
|
int n = 0;
|
|
while (n < this.fileExts.length) {
|
|
TypeInfo typeInfo2 = (TypeInfo)this.typesByFileExt.get(this.fileExts[n]);
|
|
if (typeInfo2.is(typeInfo)) {
|
|
arrayList.add(this.fileExts[n]);
|
|
}
|
|
++n;
|
|
}
|
|
return arrayList.toArray(new String[arrayList.size()]);
|
|
}
|
|
|
|
public TypeInfo getFileTypeForExtension(String string) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByFileExt.get(TextUtil.toLowerCase((String)string));
|
|
if (nTypeInfo == null) {
|
|
return this.getType("baja:DataFile");
|
|
}
|
|
return nTypeInfo;
|
|
}
|
|
|
|
public String[] getOrdSchemes() {
|
|
return (String[])this.ordSchemes.clone();
|
|
}
|
|
|
|
public TypeInfo getOrdScheme(String string) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByOrdScheme.get(TextUtil.toLowerCase((String)string));
|
|
if (nTypeInfo == null) {
|
|
throw new UnknownSchemeException(string);
|
|
}
|
|
return nTypeInfo;
|
|
}
|
|
|
|
public boolean isOrdScheme(String string) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByOrdScheme.get(TextUtil.toLowerCase((String)string));
|
|
boolean bl = false;
|
|
if (nTypeInfo != null) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public LexiconInfo[] getLexicons() {
|
|
return this.lexicons.values().toArray(new LexiconInfo[this.lexicons.size()]);
|
|
}
|
|
|
|
public LexiconInfo[] getLexicons(String string) {
|
|
return this.getLexicons(string, null);
|
|
}
|
|
|
|
public LexiconInfo[] getLexicons(String string, String string2) {
|
|
ArrayList<LexiconInfo> arrayList = new ArrayList<LexiconInfo>();
|
|
Iterator iterator = this.lexicons.values().iterator();
|
|
String string3 = string2;
|
|
if (string2 == null) {
|
|
string3 = "";
|
|
}
|
|
while (iterator.hasNext()) {
|
|
LexiconInfo lexiconInfo = (LexiconInfo)iterator.next();
|
|
if (!lexiconInfo.getModuleName().equalsIgnoreCase(string) || !lexiconInfo.getLanguage().equalsIgnoreCase(string3)) continue;
|
|
arrayList.add(lexiconInfo);
|
|
}
|
|
return arrayList.toArray(new LexiconInfo[arrayList.size()]);
|
|
}
|
|
|
|
public LexiconInfo getLexicon(String string, String string2, String string3) {
|
|
LexiconInfo lexiconInfo;
|
|
String string4 = string;
|
|
if (string2 != null && string2.length() > 0) {
|
|
string4 = string + '-' + string2;
|
|
}
|
|
if ((lexiconInfo = (LexiconInfo)this.lexicons.get(string4 = string4 + '-' + string3)) == null) {
|
|
throw new RegistryException("Unknown lexicon" + string4);
|
|
}
|
|
return lexiconInfo;
|
|
}
|
|
|
|
void read(InputStream inputStream) throws Exception {
|
|
DataInputStream dataInputStream = new DataInputStream(inputStream);
|
|
this.readHeader(dataInputStream);
|
|
this.readModules(dataInputStream);
|
|
this.readTypes(dataInputStream);
|
|
this.readDefs(dataInputStream);
|
|
this.readFileExts(dataInputStream);
|
|
this.readOrdSchemes(dataInputStream);
|
|
this.readLexicons(dataInputStream);
|
|
this.readAdapters(dataInputStream);
|
|
dataInputStream.close();
|
|
}
|
|
|
|
void readHeader(DataInputStream dataInputStream) throws Exception {
|
|
if (dataInputStream.readLong() != 7958534985112118370L) {
|
|
throw new IOException("Invalid magic");
|
|
}
|
|
if (dataInputStream.readInt() != 3) {
|
|
throw new IOException("Invalid version");
|
|
}
|
|
int n = dataInputStream.readInt();
|
|
this.modules = new NModuleInfo[n];
|
|
this.modulesByName = new HashMap(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
this.modules[n2] = new NModuleInfo(n2);
|
|
++n2;
|
|
}
|
|
n2 = dataInputStream.readInt();
|
|
this.types = new NTypeInfo[n2];
|
|
this.typesBySpec = new HashMap(n2 * 3);
|
|
int n3 = 0;
|
|
while (n3 < n2) {
|
|
this.types[n3] = new NTypeInfo(n3, null);
|
|
++n3;
|
|
}
|
|
}
|
|
|
|
void readModules(DataInputStream dataInputStream) throws Exception {
|
|
int n = 0;
|
|
while (n < this.modules.length) {
|
|
NModuleInfo nModuleInfo = this.modules[n];
|
|
nModuleInfo.read(this, dataInputStream);
|
|
this.modulesByName.put(nModuleInfo.moduleName, nModuleInfo);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
void readTypes(DataInputStream dataInputStream) throws Exception {
|
|
Array array;
|
|
NTypeInfo[] nTypeInfoArray;
|
|
NTypeInfo nTypeInfo;
|
|
int n = 0;
|
|
while (n < this.types.length) {
|
|
NTypeInfo nTypeInfo2 = this.types[n];
|
|
nTypeInfo2.read(this, dataInputStream);
|
|
this.typesBySpec.put(nTypeInfo2.toString(), nTypeInfo2);
|
|
++n;
|
|
}
|
|
HashMap<NTypeInfo[], Array> hashMap = new HashMap<NTypeInfo[], Array>();
|
|
int n2 = 0;
|
|
while (n2 < this.types.length) {
|
|
nTypeInfo = this.types[n2];
|
|
int n3 = 0;
|
|
while (n3 < nTypeInfo.agents.length) {
|
|
nTypeInfoArray = nTypeInfo.agents[n3];
|
|
array = (Array)hashMap.get(nTypeInfoArray);
|
|
if (array == null) {
|
|
Class clazz = class$com$tridium$sys$registry$NAgentInfo;
|
|
if (clazz == null) {
|
|
clazz = RegistryDatabase.class("[Lcom.tridium.sys.registry.NAgentInfo;", false);
|
|
}
|
|
array = new Array(clazz);
|
|
hashMap.put(nTypeInfoArray, array);
|
|
}
|
|
array.add((Object)new NAgentInfo(nTypeInfo));
|
|
++n3;
|
|
}
|
|
++n2;
|
|
}
|
|
Iterator iterator = hashMap.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
nTypeInfo = (NTypeInfo)iterator.next();
|
|
Array array2 = (Array)hashMap.get(nTypeInfo);
|
|
nTypeInfoArray = new NTypeInfo[array2.size()];
|
|
array = (Array)array2.trim();
|
|
int n4 = 0;
|
|
while (n4 < ((NAgentInfo[])array).length) {
|
|
nTypeInfoArray[n4] = (NTypeInfo)array[n4].getTypeInfo();
|
|
++n4;
|
|
}
|
|
nTypeInfo.agentOn = nTypeInfoArray;
|
|
}
|
|
}
|
|
|
|
void readDefs(DataInputStream dataInputStream) throws Exception {
|
|
int n = dataInputStream.readInt();
|
|
this.defs = new HashMap(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
String string = dataInputStream.readUTF();
|
|
int n3 = dataInputStream.readUnsignedByte();
|
|
String[] stringArray = new String[n3];
|
|
int n4 = 0;
|
|
while (n4 < n3) {
|
|
stringArray[n4] = dataInputStream.readUTF();
|
|
++n4;
|
|
}
|
|
this.defs.put(string, stringArray);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void readFileExts(DataInputStream dataInputStream) throws Exception {
|
|
int n = dataInputStream.readUnsignedShort();
|
|
this.fileExts = new String[n];
|
|
this.typesByFileExt = new HashMap(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
String string;
|
|
this.fileExts[n2] = string = dataInputStream.readUTF();
|
|
this.typesByFileExt.put(string, this.types[dataInputStream.readUnsignedShort()]);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void readOrdSchemes(DataInputStream dataInputStream) throws Exception {
|
|
int n = dataInputStream.readUnsignedShort();
|
|
this.ordSchemes = new String[n];
|
|
this.typesByOrdScheme = new HashMap(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
String string;
|
|
this.ordSchemes[n2] = string = dataInputStream.readUTF();
|
|
this.typesByOrdScheme.put(string, this.types[dataInputStream.readUnsignedShort()]);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void readLexicons(DataInputStream dataInputStream) throws Exception {
|
|
int n = dataInputStream.readInt();
|
|
this.lexicons = new HashMap(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
NLexiconInfo nLexiconInfo = new NLexiconInfo();
|
|
nLexiconInfo.read(dataInputStream);
|
|
String string = nLexiconInfo.getModuleName();
|
|
String string2 = nLexiconInfo.getLanguage();
|
|
String string3 = nLexiconInfo.getContainerModuleName();
|
|
if (string2 != null && string2.length() > 0) {
|
|
string = string + '-' + string2;
|
|
}
|
|
string = string + '-' + string3;
|
|
this.lexicons.put(string, nLexiconInfo);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void readAdapters(DataInputStream dataInputStream) throws Exception {
|
|
int n = dataInputStream.readUnsignedShort();
|
|
this.adapters = new NAdapterInfo[n];
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
this.adapters[n2] = new NAdapterInfo();
|
|
this.adapters[n2].read(this, dataInputStream);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
public BModule synthesizeModule(String string, Version version, String string2, Version version2, String string3) {
|
|
if (this.modulesByName.containsKey(string)) {
|
|
throw new RegistryException("Duplicate module name: " + string);
|
|
}
|
|
NModuleInfo nModuleInfo = new NModuleInfo(-1);
|
|
nModuleInfo.moduleName = string;
|
|
nModuleInfo.bajaVersion = version;
|
|
nModuleInfo.vendor = string2;
|
|
nModuleInfo.vendorVersion = version2;
|
|
nModuleInfo.description = string3;
|
|
nModuleInfo.hasPalette = false;
|
|
nModuleInfo.buildTime = BAbsTime.now().getMillis();
|
|
nModuleInfo.types = NTypeInfo.noTypes;
|
|
nModuleInfo.moduleContent = "doc";
|
|
nModuleInfo.depends = new NDependencyInfo[0];
|
|
nModuleInfo.isTransientModule = true;
|
|
this.modulesByName.put(nModuleInfo.moduleName, nModuleInfo);
|
|
this.modules = (NModuleInfo[])ArrayUtil.addOne(this.modules, nModuleInfo);
|
|
SortUtil.sort((Object[])this.modules);
|
|
return Nre.moduleManager.synthesizeModule(nModuleInfo).bmodule();
|
|
}
|
|
|
|
public Type synthesizeType(BTypeSpec bTypeSpec, String string, TypeInfo typeInfo, TypeInfo[] typeInfoArray, AgentInfo[] agentInfoArray, boolean bl, boolean bl2) {
|
|
if (this.typesBySpec.get(bTypeSpec.toString()) != null) {
|
|
throw new RegistryException("Type already exists: " + bTypeSpec);
|
|
}
|
|
if (!this.modulesByName.containsKey(bTypeSpec.getModuleName())) {
|
|
throw new RegistryException("Module does not exist: " + bTypeSpec.getModuleName());
|
|
}
|
|
if (!string.startsWith("auto.")) {
|
|
throw new IllegalArgumentException("Class package must start with 'auto.'.");
|
|
}
|
|
if (!string.endsWith(".B" + bTypeSpec.getTypeName())) {
|
|
throw new IllegalArgumentException("TypeSpec does not match class name.");
|
|
}
|
|
if (typeInfo.is(BFrozenEnum.TYPE) && !bl2) {
|
|
throw new IllegalArgumentException("Frozen enumerations must be declared final.");
|
|
}
|
|
NTypeInfo nTypeInfo = new NTypeInfo(-1, bTypeSpec);
|
|
nTypeInfo.superType = (NTypeInfo)typeInfo;
|
|
nTypeInfo.lexicon = Lexicon.make("baja");
|
|
nTypeInfo.className = string;
|
|
nTypeInfo.isTransientType = true;
|
|
boolean bl3 = false;
|
|
NTypeInfo[] nTypeInfoArray = new NTypeInfo[typeInfoArray.length];
|
|
int n = 0;
|
|
while (n < typeInfoArray.length) {
|
|
nTypeInfoArray[n] = (NTypeInfo)typeInfoArray[n];
|
|
if (typeInfoArray[n].is(BIAgent.TYPE)) {
|
|
bl3 = true;
|
|
}
|
|
++n;
|
|
}
|
|
nTypeInfo.interfaces = nTypeInfoArray;
|
|
if (agentInfoArray.length > 0 && !bl3) {
|
|
throw new RegistryException("Type is an agent on other types, but does not implement BIAgent.");
|
|
}
|
|
NTypeInfo[] nTypeInfoArray2 = new NTypeInfo[agentInfoArray.length];
|
|
int n2 = 0;
|
|
while (n2 < agentInfoArray.length) {
|
|
nTypeInfoArray2[n2] = (NTypeInfo)agentInfoArray[n2].getAgentType();
|
|
++n2;
|
|
}
|
|
nTypeInfo.agentOn = nTypeInfoArray2;
|
|
n2 = 0;
|
|
while (n2 < nTypeInfo.agentOn.length) {
|
|
ArrayUtil.addOne(nTypeInfo.agentOn[n2].agents, nTypeInfo);
|
|
++n2;
|
|
}
|
|
n2 = 1;
|
|
if (bl) {
|
|
n2 |= 0x400;
|
|
}
|
|
if (bl2) {
|
|
n2 |= 0x10;
|
|
}
|
|
nTypeInfo.modifiers = n2;
|
|
Object object = new Builder.IsMap();
|
|
NTypeInfo nTypeInfo2 = nTypeInfo;
|
|
while (nTypeInfo2 != null) {
|
|
((Builder.IsMap)object).add(nTypeInfo2);
|
|
nTypeInfo2 = nTypeInfo2.superType;
|
|
}
|
|
nTypeInfo2 = nTypeInfo;
|
|
while (nTypeInfo2 != null) {
|
|
this.mapInterfaces((Builder.IsMap)object, nTypeInfo2);
|
|
nTypeInfo2 = nTypeInfo2.superType;
|
|
}
|
|
nTypeInfo.is = ((Builder.IsMap)object).toArray();
|
|
this.types = (NTypeInfo[])ArrayUtil.addOne(this.types, nTypeInfo);
|
|
this.typesBySpec.put(nTypeInfo.toString(), nTypeInfo);
|
|
object = (NModuleInfo)this.modulesByName.get(bTypeSpec.getModuleName());
|
|
((NModuleInfo)object).types = (NTypeInfo[])ArrayUtil.addOne(((NModuleInfo)object).types, nTypeInfo);
|
|
Nre.moduleManager.synthesizeType(bTypeSpec, string, typeInfo, typeInfoArray, bl, bl2);
|
|
return bTypeSpec.getResolvedType();
|
|
}
|
|
|
|
private final void mapInterfaces(Builder.IsMap isMap, NTypeInfo nTypeInfo) {
|
|
if (nTypeInfo.isInterface()) {
|
|
isMap.add(nTypeInfo);
|
|
}
|
|
int n = 0;
|
|
while (n < nTypeInfo.interfaces.length) {
|
|
this.mapInterfaces(isMap, nTypeInfo.interfaces[n]);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
void write(File file) throws Exception {
|
|
DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
|
|
this.writeHeader(dataOutputStream);
|
|
this.writeModules(dataOutputStream);
|
|
this.writeTypes(dataOutputStream);
|
|
this.writeDefs(dataOutputStream);
|
|
this.writeFileExts(dataOutputStream);
|
|
this.writeOrdSchemes(dataOutputStream);
|
|
this.writeLexicons(dataOutputStream);
|
|
this.writeAdapters(dataOutputStream);
|
|
dataOutputStream.close();
|
|
}
|
|
|
|
void writeHeader(DataOutputStream dataOutputStream) throws Exception {
|
|
dataOutputStream.writeLong(7958534985112118370L);
|
|
dataOutputStream.writeInt(3);
|
|
dataOutputStream.writeInt(this.modules.length);
|
|
dataOutputStream.writeInt(this.types.length);
|
|
}
|
|
|
|
void writeModules(DataOutputStream dataOutputStream) throws Exception {
|
|
int n = 0;
|
|
while (n < this.modules.length) {
|
|
this.modules[n].write(this, dataOutputStream);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
void writeTypes(DataOutputStream dataOutputStream) throws Exception {
|
|
int n = 0;
|
|
while (n < this.types.length) {
|
|
this.types[n].write(this, dataOutputStream);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
void writeDefs(DataOutputStream dataOutputStream) throws Exception {
|
|
dataOutputStream.writeInt(this.defs.size());
|
|
Iterator iterator = this.defs.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
String string = (String)iterator.next();
|
|
String[] stringArray = (String[])this.defs.get(string);
|
|
dataOutputStream.writeUTF(string);
|
|
dataOutputStream.write(stringArray.length);
|
|
int n = 0;
|
|
while (n < stringArray.length) {
|
|
dataOutputStream.writeUTF(stringArray[n]);
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
|
|
void writeFileExts(DataOutputStream dataOutputStream) throws Exception {
|
|
int n = this.fileExts.length;
|
|
dataOutputStream.writeShort(n);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
String string = this.fileExts[n2];
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByFileExt.get(string);
|
|
dataOutputStream.writeUTF(string);
|
|
dataOutputStream.writeShort(nTypeInfo.id);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void writeOrdSchemes(DataOutputStream dataOutputStream) throws Exception {
|
|
int n = this.ordSchemes.length;
|
|
dataOutputStream.writeShort(n);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
String string = this.ordSchemes[n2];
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByOrdScheme.get(string);
|
|
dataOutputStream.writeUTF(string);
|
|
dataOutputStream.writeShort(nTypeInfo.id);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
void writeLexicons(DataOutputStream dataOutputStream) throws Exception {
|
|
dataOutputStream.writeInt(this.lexicons.size());
|
|
Iterator iterator = this.lexicons.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
String string = (String)iterator.next();
|
|
NLexiconInfo nLexiconInfo = (NLexiconInfo)this.lexicons.get(string);
|
|
nLexiconInfo.write(dataOutputStream);
|
|
}
|
|
}
|
|
|
|
void writeAdapters(DataOutputStream dataOutputStream) throws Exception {
|
|
int n = this.adapters.length;
|
|
dataOutputStream.writeShort(n);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
this.adapters[n2].write(this, dataOutputStream);
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
|