/**
* Returns the index of the given relation in the relation sort order, or the index of "*" if the
* relation is not explicitly listed.
*/
public Integer getRelationSortIndex(String rel) {
Integer retval = _relationIndexMap.get(rel);
if (retval != null) return retval;
retval = _relationIndexMap.get("*");
if (retval != null) return retval;
return new Integer(-1);
}
public static int register(KeyBinding b, boolean forceUpdate) {
// Search for binding if it already exists
for (Integer id : bindings.keySet()) {
KeyBinding tb = bindings.get(id);
if (tb.pluginName.equals(b.pluginName) && tb.description.equals(b.description)) {
if (forceUpdate) bindings.put(id, b);
return id;
}
}
// Generate new binding
nextId++;
bindings.put(nextId, b);
return nextId;
}
// get relation sort order, or use defaults
private void loadRelationSortOrder(Element relationSortingElt) {
// use defaults if no order specified
if (relationSortingElt == null) {
for (int i = 0; i < defaultRelationSortOrder.length; i++) {
_relationIndexMap.put(defaultRelationSortOrder[i], new Integer(i));
}
return;
}
// otherwise load from 'order' attribute
String orderAttr = relationSortingElt.getAttributeValue("order");
String[] relSortOrder = orderAttr.split("\\s+");
for (int i = 0; i < relSortOrder.length; i++) {
_relationIndexMap.put(relSortOrder[i], new Integer(i));
}
}
/**
* 普通版填写包的公共部分
* @param root 开始节点
* @param map 参数map
* @param sCycName 循环节点名
* @return
*/
public Element writeptPublicNode(Element root,HashMap map,String sCycName)
{
Element node=null;
try
{
String sName="";
String sValue="";
List list=root.getChildren();
for(int i=0;i<list.size();i++)
{
node=(Element)list.get(i);
sName=node.getName();
sName=sName.trim();
sValue=(String)map.get(sName);
//System.err.println("sName:"+sName+":"+sValue);
if(sCycName.equals(sName)&&(root.getName()).trim().equals("ReqParamSet"))
{
//System.err.println("find cyc node:"+sName );
return node;
}
else if(sValue!=null && !"".equals(sValue) )
node.setText(sValue);
node=writeptPublicNode(node,map,sCycName);
}
}catch(Exception ex)
{
ex.printStackTrace();
System.err.println("error:"+ex.getMessage());
}
return node;
}
// returns a macro adder for the given morph item
private MacroAdder getMacAdder(MorphItem mi) {
// check map
MacroAdder retval = macAdderMap.get(mi);
if (retval != null) return retval;
// set up macro adder
IntHashSetMap macrosFromLex = new IntHashSetMap();
String[] newMacroNames = mi.getMacros();
List<MacroItem> macroItems = new ArrayList<MacroItem>();
for (int i = 0; i < newMacroNames.length; i++) {
Set<FeatureStructure> featStrucs = (Set<FeatureStructure>) _macros.get(newMacroNames[i]);
if (featStrucs != null) {
for (Iterator<FeatureStructure> fsIt = featStrucs.iterator(); fsIt.hasNext(); ) {
FeatureStructure fs = fsIt.next();
macrosFromLex.put(fs.getIndex(), fs);
}
}
MacroItem macroItem = _macroItems.get(newMacroNames[i]);
if (macroItem != null) {
macroItems.add(macroItem);
} else {
// should be checked earlier too
System.err.println(
"Warning: macro " + newMacroNames[i] + " not found for word '" + mi.getWord() + "'");
}
}
retval = new MacroAdder(macrosFromLex, macroItems);
// update map and return
macAdderMap.put(mi, retval);
return retval;
}
/**
*
* @param 普通版list 参数列表
*/
public void writeptParaList(ArrayList list)
{
try {
String sCaseName="";
String sItem="";
String sCycName="";
HashMap map=null;
Document doc = builder.build(xmlFileName);
Element root = doc.getRootElement();
Element element = root;
Element cycNode=null;
map=(HashMap)list.get(0); //参数文件map
sItem="Description";
sCaseName=(String)map.get(sItem);
mypage.FcfeMain.wR(mypage.FcfeMain.SIM_APP_ERP, "Description=" + sCaseName );
sItem="CysName";
sCycName=(String)map.get(sItem);
map=(HashMap)list.get(1); //public 参数map
cycNode=writeptPublicNode(element,map,sCycName);
if( writeCycNode(cycNode,list)==false) //循环 参数
System.err.println(" write cyc node fail");
XMLOutputter outputter = new XMLOutputter("", false, "GB2312");
PrintWriter out = new PrintWriter(new BufferedWriter(
new FileWriter(xmlFileName)));
Document myDocument = root.getDocument();
outputter.output(myDocument, out);
out.close();
} catch (JDOMException jdome) {
jdome.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @param map 需要写入的参数map
* @param start 开始节点
* @param bNew 是否新增节点再写入参数
* @return
*/
public void writeParaMap(Element start,HashMap map)
{
try
{
String sName="";
String sValue="";
Element node=null;
List list=start.getChildren();
for(int i=0;i<list.size();i++)
{
node=(Element)list.get(i);
sName=node.getName();
sName=sName.trim();
sValue=(String)map.get(sName);
if(sValue!=null && !"".equals(sValue) );
node.setText(sValue);
}
}catch(Exception ex)
{
ex.printStackTrace();
System.err.println("error:"+ex.getMessage());
}
return ;
}
/** Get a key binding */
public static KeyBinding get(int id) {
return bindings.get(id);
}
/** Loads the lexicon and morph files. */
public void init(URL lexiconUrl, URL morphUrl) throws IOException {
List<Family> lexicon = null;
List<MorphItem> morph = null;
List<MacroItem> macroModel = null;
// load category families (lexicon), morph forms and macros
lexicon = getLexicon(lexiconUrl);
Pair<List<MorphItem>, List<MacroItem>> morphInfo = getMorph(morphUrl);
morph = morphInfo.a;
macroModel = morphInfo.b;
// index words; also index stems to words, as default preds
// store indexed coarticulation attrs too
_words = new GroupMap<Word, MorphItem>();
_predToWords = new GroupMap<String, Word>();
_coartAttrs = new HashSet<String>();
_indexedCoartAttrs = new HashSet<String>();
for (MorphItem morphItem : morph) {
Word surfaceWord = morphItem.getSurfaceWord();
_words.put(surfaceWord, morphItem);
_predToWords.put(morphItem.getWord().getStem(), surfaceWord);
if (morphItem.isCoart()) {
Word indexingWord = morphItem.getCoartIndexingWord();
_words.put(indexingWord, morphItem);
Pair<String, String> first = indexingWord.getSurfaceAttrValPairs().next();
_indexedCoartAttrs.add(first.a);
for (Iterator<Pair<String, String>> it = surfaceWord.getSurfaceAttrValPairs();
it.hasNext(); ) {
Pair<String, String> p = it.next();
_coartAttrs.add(p.a);
}
}
}
// index entries based on stem+pos
_stems = new GroupMap<String, Object>();
_posToEntries = new GroupMap<String, EntriesItem[]>();
// index entries by supertag+pos, for supertagging
_stagToEntries = new GroupMap<String, EntriesItem>();
// also index rels and coart rels to preds
_relsToPreds = new GroupMap<String, String>();
_coartRelsToPreds = new GroupMap<String, String>();
// and gather list of attributes used per atomic category type
_catsToAttrs = new GroupMap<String, String>();
_lfAttrs = new HashSet<String>();
// and remember family and ent, names, for checking excluded list on morph items
HashSet<String> familyAndEntryNames = new HashSet<String>();
// index each family
for (Family family : lexicon) {
familyAndEntryNames.add(family.getName());
EntriesItem[] entries = family.getEntries();
DataItem[] data = family.getData();
// for generic use when we get an unknown stem
// from the morphological analyzer
if (!family.isClosed()) {
_posToEntries.put(family.getPOS(), entries);
}
// scan through entries
for (int j = 0; j < entries.length; j++) {
// index
EntriesItem eItem = entries[j];
_stagToEntries.put(eItem.getSupertag() + family.getPOS(), eItem);
if (eItem.getStem().length() > 0) {
_stems.put(eItem.getStem() + family.getPOS(), eItem);
}
try {
// gather features
eItem.getCat().forall(gatherAttrs);
// record names
familyAndEntryNames.add(eItem.getName());
familyAndEntryNames.add(eItem.getQualifiedName());
} catch (RuntimeException exc) {
System.err.println("exception for: " + family.getName() + ": " + exc);
}
}
// scan through data
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_stems.put(
dItem.getStem() + family.getPOS(), new Pair<DataItem, EntriesItem[]>(dItem, entries));
// index non-default preds to words
if (!dItem.getStem().equals(dItem.getPred())) {
Collection<Word> words = (Collection<Word>) _predToWords.get(dItem.getStem());
if (words == null) {
if (!openlex) {
System.out.print("Warning: couldn't find words for pred '");
System.out.println(dItem.getPred() + "' with stem '" + dItem.getStem() + "'");
}
} else {
for (Iterator<Word> it = words.iterator(); it.hasNext(); ) {
_predToWords.put(dItem.getPred(), it.next());
}
}
}
}
// index rels to preds
// nb: this covers relational (eg @x<GenRel>e) and featural (eg @e<tense>past)
// elementary predications
List<String> indexRels = new ArrayList<String>(3);
String familyIndexRel = family.getIndexRel();
if (familyIndexRel.length() > 0) {
indexRels.add(familyIndexRel);
}
for (int j = 0; j < entries.length; j++) {
EntriesItem eItem = entries[j];
String indexRel = eItem.getIndexRel();
if (indexRel.length() > 0 && !indexRel.equals(familyIndexRel)) {
indexRels.add(indexRel);
}
}
for (Iterator<String> it = indexRels.iterator(); it.hasNext(); ) {
String indexRel = it.next();
// nb: not indexing on entries items, b/c some stems are still defaults
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_relsToPreds.put(indexRel, dItem.getPred());
}
}
// index coart rels (features, really) to preds
String coartRel = family.getCoartRel();
if (coartRel.length() > 0) {
for (int j = 0; j < data.length; j++) {
_coartRelsToPreds.put(coartRel, data[j].getPred());
}
}
}
// index the macros
_macros = new GroupMap<String, FeatureStructure>();
// nb: could just index MacroItem objects for feature structures too;
// this might be a bit cleaner, but life is short
_macroItems = new HashMap<String, MacroItem>();
for (MacroItem mi : macroModel) {
String macName = mi.getName();
FeatureStructure[] specs = mi.getFeatureStructures();
for (int j = 0; j < specs.length; j++) {
_macros.put(macName, specs[j]);
}
// this is for handling LF part of macros
_macroItems.put(macName, mi);
}
// with morph items, check POS, macro names, excluded list for xref
for (MorphItem morphItem : morph) {
Word w = morphItem.getWord();
if (!openlex
&& !_stems.containsKey(w.getStem() + w.getPOS())
&& !_posToEntries.containsKey(w.getPOS())) {
System.err.println(
"Warning: no entries for stem '"
+ w.getStem()
+ "' and POS '"
+ w.getPOS()
+ "' found for word '"
+ w
+ "'");
}
String[] macroNames = morphItem.getMacros();
for (int j = 0; j < macroNames.length; j++) {
if (!_macroItems.containsKey(macroNames[j])) {
System.err.println(
"Warning: macro "
+ macroNames[j]
+ " not found for word '"
+ morphItem.getWord()
+ "'");
}
}
String[] excludedNames = morphItem.getExcluded();
for (int j = 0; j < excludedNames.length; j++) {
if (!familyAndEntryNames.contains(excludedNames[j])) {
System.err.println(
"Warning: excluded family or entry '"
+ excludedNames[j]
+ "' not found for word '"
+ morphItem.getWord()
+ "'");
}
}
}
}