File: [ecoinformatics] / jalama / src / edu / ucsb / nceas / jalama / generation / rulesengine / drools / XSElementDeclarationWrapper.java (download)
Revision 1.49, Sat Feb 12 01:55:21 2005 UTC (5 years, 6 months ago) by brooke
Branch: MAIN
CVS Tags: PRE_UI_JARFILE_UPLOAD_20050428, HEAD, BETA3_RELEASE_AUG2005
Changes since 1.48: +270 -24
lines
added methods addAttributesToXBLOrderAsOriginal() and addAttributesToXBLOrderByAlpha() to reorder (or not) attributes added to XBL for 2-d dropdown list. removed reordering from javascript in xbl code in an attempt to speed up rendering. changed rules to call new method
|
/**
* '$RCSfile: XSElementDeclarationWrapper.java,v $'
* Copyright: 2002 Regents of the University of California and the
* National Center for Ecological Analysis and Synthesis
* Authors: @authors@
* Release: @release@
*
* '$Author: brooke $'
* '$Date: 2005/02/12 01:55:21 $'
* '$Revision: 1.49 $'
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.ucsb.nceas.jalama.generation.rulesengine.drools;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.xml.transform.TransformerException;
import org.apache.log4j.Logger;
import org.apache.xerces.impl.xs.psvi.XSAttributeUse;
import org.apache.xerces.impl.xs.psvi.XSComplexTypeDefinition;
import org.apache.xerces.impl.xs.psvi.XSElementDeclaration;
import org.apache.xerces.impl.xs.psvi.XSModel;
import org.apache.xerces.impl.xs.psvi.XSModelGroup;
import org.apache.xerces.impl.xs.psvi.XSObjectList;
import org.apache.xerces.impl.xs.psvi.XSParticle;
import org.apache.xerces.impl.xs.psvi.XSTerm;
import org.apache.xerces.impl.xs.psvi.XSTypeDefinition;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.ucsb.nceas.jalama.exception.RuleExecutionException;
import edu.ucsb.nceas.jalama.generation.PatternMatcherAdaptor;
import edu.ucsb.nceas.jalama.generation.UIGenController;
import edu.ucsb.nceas.jalama.generation.XBLBinding;
import edu.ucsb.nceas.jalama.generation.XMLSchemaElementTypes;
import edu.ucsb.nceas.jalama.generation.XMLSchemaUtilities;
import edu.ucsb.nceas.util.Settings;
import edu.ucsb.nceas.utilities.OrderedMap;
import edu.ucsb.nceas.utilities.XMLUtilities;
import java.text.Collator;
import java.util.Locale;
import java.text.CollationKey;
public class XSElementDeclarationWrapper {
private static Logger log = Logger.getLogger(XSElementDeclarationWrapper.class.
getName());
/** global element that refers to that passed in when constructed **/
private XSElementDeclaration element;
/** xpath to this element **/
private String path;
/** schema element types: edu.ucsb.nceas.jalama.generation.XMLSchemaElementType **/
private short elementType;
/** the name of the element **/
private String name;
/** the first element in the schema **/
private String firstSchemaElement;
/** the name of the parent node **/
private String parentElementName;
private String parentXPath;
/** min and max allowable occurences of element allowed in the schema **/
private int minOccurs;
private int maxOccurs;
/** total number of input widgets in the entire document. These are identified
* by looking at the XBLBinding isFocusable attribute, as defined in
* jalama_XBL_API.xml
**/
private int totalWidgetHeight = 0;
/** group type :: CHOICE || SEQUENCE || empty string **/
private String groupType = "";
/** the reulting widget type for a given element type **/
private String widgetType = null;
private XBLBinding xbl;
private Map attributesMap;
private static int currentPageHeightRunningTotal;
private static int currentPageNumber;
private int treeDepth = 0;
/**
* constructor
* @param path String -- the xpath to the given element -- no predicates
*
* @param e XSElementDeclaration -- the XSElelemntDeclaration corresponding
* to the xpath
*
* @param schemaModel XSModel -- the PSVI XS model
*
* @param schemaDOM Document -- the XS Schema represented as a DOM
*/
public XSElementDeclarationWrapper(String path, XSElementDeclaration e,
XSModel schemaModel, Document schemaDOM) {
this.path = path.trim();
this.element = e;
this.elementType = XMLSchemaUtilities.getElementType(e);
this.minOccurs = XMLSchemaUtilities.getMinOccurs(e);
this.maxOccurs = XMLSchemaUtilities.getMaxOccurs(e);
this.name = e.getName();
this.firstSchemaElement
= XMLSchemaUtilities.getFirstSchemaElementName(schemaModel);
this.setParentName(path);
this.parentXPath = this.getParentXPath(path);
this.groupType = XMLSchemaUtilities.getSequenceVSChoice(e);
if (this.groupType == null) {
this.groupType = "";
}
this.attributesMap = this.getAttributes();
this.currentPageNumber = 0;
this.currentPageHeightRunningTotal = getWidgetHeight("root_container");
StringTokenizer st = new StringTokenizer(path, "/");
this.treeDepth = st.countTokens();
}
/**
* returns the possible choices allowed for this element as a vector of
* strings
*
* @return Vector
*/
public Vector getChoiceElementPossibilities() {
Vector vec = new Vector();
//log.debug("\n\n other 1a " + element.getTypeDefinition().getTypeCategory());
//log.debug("\n\n other 1b " + element.getTypeDefinition());
XSTypeDefinition xst = element.getTypeDefinition();
XSComplexTypeDefinition xsctd = (XSComplexTypeDefinition) xst;
XSParticle xsp = xsctd.getParticle();
XSTerm xsterm = xsp.getTerm();
//log.debug("\n\n other 1b.1 " + xsp);
//log.debug("\n\n other 1b.2 " + xsterm.getName());
XSModelGroup mg = (XSModelGroup) xsterm;
XSObjectList list = mg.getParticles();
for (int i = 0; i < list.getLength(); i++) {
// log.debug(" >>> " + ( (XSParticle) (list.item(i))).getTerm());
// log.debug(" >>> " + list.item(i));
XSTerm xsterm2 = ( (XSParticle) (list.item(i))).getTerm();
if (mg.getCompositor() == XSModelGroup.COMPOSITOR_CHOICE) {
try {
XSModelGroup mg2 = (XSModelGroup) xsterm2;
XSObjectList list2 = mg2.getParticles();
for (int ii = 0; ii < list2.getLength(); ii++) {
// log.debug(" >>>>> " + list2.item(ii));
String val = ( ( (XSParticle) (list2.item(ii))).getTerm()).getName();
// log.debug(" >>>>> " + val);
vec.addElement(val);
}
} catch (java.lang.ClassCastException cce) {
/**log.error("problem casting to get the choice possibilities at element "
+ this.path);**/
// cce.printStackTrace();
String val = xsterm2.getName();
vec.addElement(val);
}
} else {
///log.fatal("possible data loss here");
String val = xsterm2.getName();
vec.addElement(val);
}
}
return vec;
}
/**
* return the parent name
* @return -- the name of the parent element
*/
public String getParentXPath() {
return this.parentXPath;
}
/**
* returns the xpath of the parent element
*
* @return -- the xpath of the parent element
* @param child String
*/
public String getParentXPath(String child) {
if (child == null) {
return null;
} while (child.endsWith("/")) {
child = child.substring(0, child.length() - 1);
}
int i = child.lastIndexOf("/");
if (i < 0) {
return null;
}
String parent = child.substring(0, i);
return parent;
}
/**
* returns the depth in the tree that this element is at
*
* @return int
*/
public int getElementDepth() {
return this.treeDepth;
}
/**
* overrides the toString method
* @return String
*/
public String toString() {
StringBuffer sb = new StringBuffer();
String type = null;
switch ( (short)elementType) {
case ( (short)XMLSchemaElementTypes.COMPLEX):
type = "COMPLEX";
break;
case ( (short)XMLSchemaElementTypes.ENUMERATION):
type = "ENUMERATION";
break;
case ( (short)XMLSchemaElementTypes.SIMPLE_DATE):
type = "SIMPLE_DATE";
break;
case ( (short)XMLSchemaElementTypes.SIMPLE_DOUBLE):
type = "SIMPLE_DOUBLE";
break;
case ( (short)XMLSchemaElementTypes.SIMPLE_FLOAT):
type = "SIMPLE_FLOAT";
break;
case ( (short)XMLSchemaElementTypes.SIMPLE_INTEGER):
type = "SIMPLE_INTEGER";
break;
case ( (short)XMLSchemaElementTypes.SIMPLE_STRING):
type = "SIMPLE_STRING";
break;
}
String baseType = null;
try {
if ( (element.getEnclosingCTDefinition()).getBaseType().getName() != null)
baseType = (element.getEnclosingCTDefinition()).getBaseType().getName();
} catch (Exception ex) {}
sb.append(
"\n-------------------------------------------------------------------"
+ "\n --> elementType: " + elementType + " " + type
+ "\n --> xpath: " + path
+ "\n --> minOccurs: " + minOccurs
+ "\n --> maxOccurs: " + maxOccurs
+ "\n --> name: " + name
+ "\n --> firstSchemaElementName: " + firstSchemaElement
+ "\n --> parentElementName: " + parentElementName
+ "\n --> groupType: " + groupType
+ "\n --> attributes: " + this.attributesMap
+ "\n --> parent xpath: " + this.parentXPath
+ "\n other 1 " + element.getEnclosingCTDefinition()
+ "\n --> type: " + baseType
+ "\n --> treeDepth: " + this.treeDepth
+ "\n------------------------------------------------------------------\n");
return sb.toString();
/***
log.debug("\n\n other 1a " + e.getTypeDefinition().getTypeCategory());
log.debug("\n\n other 1b " + e.getTypeDefinition());
log.debug("\n\n other 1c " + e.getTypeDefinition().getBaseType());
log.debug("\n\n other 1c.1 "
+ e.getTypeDefinition().getBaseType().getName());
log.debug("\n\n other 2 " + e);
log.debug("\n\n other 3 " + e.getType());
log.debug("\n\n other 4 " + e.getEnclosingCTDefinition());
log.debug("\n\n other 5 " + e.getEnclosingCTDefinition().getParticle());
log.debug("\n\n other 6 "
+ e.getEnclosingCTDefinition().getParticle().getTerm());
***/
/** if (e.getEnclosingCTDefinition() != null) {
log.debug("other 7 -- should be the attributes"
+ this.getAttributes() + "\n\n\n\n");
} **/
/***
//if ( path.equals("/eml:eml/dataset/dataTable/physical/distribution/inline") )
System.exit(0);
//}
}
***/
}
/**
* returns the attributes for this element
*
* @return Hashtable
*/
public Hashtable getAttributes() {
XSTypeDefinition typeDef = element.getTypeDefinition();
if (typeDef.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
XSComplexTypeDefinition comp = (XSComplexTypeDefinition) typeDef;
return this.getAttributes(comp);
} else {return null;}
}
/**
* returns the attributes for this element as a list
*
* @return List -- a list of all the attributes for this element
*/
public List getAttributesAsList() {
if ( this.attributesMap != null) {
Iterator it = this.attributesMap.keySet().iterator();
Vector atts = new Vector();
while (it.hasNext()) {
String attribute = (String)it.next();
atts.addElement(attribute);
}
return atts;
} else {
return null;
}
}
/**
* Takes an XS Complex Type Definition and returns a Hashtable of the
* attributes, else null or an empty string. So for instance:
*
* /eml:eml/dataset/access --> scope=, system=, id=
* -----------------------------------
* | attribute id | constraint value |
* -----------------------------------
*
* @param compl XSComplexTypeDefinition
* @return Hashtable
*/
private Hashtable getAttributes(XSComplexTypeDefinition compl) {
if (compl == null) {
return null;
}
Hashtable attr_hash = new Hashtable();
XSObjectList attlist = compl.getAttributeUses();
for (int i = 0; i < attlist.getLength(); i++) {
XSAttributeUse au = (XSAttributeUse) (attlist.item(i));
if (au == null) {
log.info("attribute use is null!");
}
String name = (au.getAttrDeclaration()).getName();
if (name == null) {
log.info("Attribute name is null!");
}
String val = au.getConstraintValue();
if (val == null) {
val = "";
}
attr_hash.put(name, val);
}
return attr_hash;
}
/**
* returns the string value of the type like
* anyType, anyURI, anySimpleTyoe ...
*
* type >>>> anySimpleType
* type >>>> anyType
* type >>>> anyURI
* type >>>> Book
* type >>>> Chapter
* type >>>> decimal
* type >>>> float
* type >>>> integer
* type >>>> long
* type >>>> nonNegativeInteger
* type >>>> ProcedureStepType
* type >>>> ResponsibleParty
* type >>>> string
* type >>>> TaxonomicCoverage
* type >>>> TemporalCoverage
* type >>>> unsignedLong
*
* @return String
*/
public String getElementBaseType() {
return element.getTypeDefinition().getBaseType().getName();
}
public XBLBinding getXBLBinding() {
return this.xbl;
}
public void setXBLBinding(XBLBinding xbl) {
this.xbl = xbl;
}
public String getPath() {
return this.path;
}
/**
* this returns boolean true if the descendant node (ie a node in
* this node's subtree) exists at the absolute xpath provided; false otherwise
*
* @param xPath the (String) xpath of the node relative to
* the root, WITH PREDICATES. No trailing slash. Wildcards may be
* used - eg: /person/course[1]/course_name[1]
* //course_name[1]
*
* @return boolean true if the descendant node (ie a node in
* this node's subtree) exists at the relative xpath provided; false otherwise
*
* @throws RuleExecutionException if there is no input DOM (ie if we're
* generating UI from a non-inferred schema doc.)
*/
public static boolean isDOMNodePresentAtAbsoluteXPath(String xPath) {
log.debug("\n\n*** isDOMNodePresentAtAbsoluteXPath() got relXPath: "
+ xPath + "\n***\n\n");
if (xPath == null)return false;
Node inputDOMRootNode = UIGenController.getInstance().getInputDOMRootNode();
if (inputDOMRootNode == null) {
log.warn("isDOMNodePresentAtAbsoluteXPath(): there is no input DOM \n"
+ "(are you generating a UI from a non-inferred schema doc?)");
return false;
}
NodeList nList = null;
try {
nList = XMLUtilities.getNodeListWithXPath(inputDOMRootNode, xPath);
} catch (Exception ex) {
log.error("*** Exception doing XMLUtilities.getNodeListWithXPath()" + ex);
log.error("*** xpath was: " + xPath);
ex.printStackTrace();
}
int totNodes = (nList != null) ? nList.getLength() : -1;
log.debug("\n\n*** isDOMNodePresentAtAbsoluteXPath() found: "
+ totNodes + " nodes\n for xpath: "
+ xPath + "\nreturning " + (totNodes > 0) + "***\n\n");
return (totNodes > 0);
}
/**
* this returns boolean true if the decsendant node (ie a node in
* this node's subtree) exists at the relative xpath provided; false otherwise
*
* @param relXPath the (String) xpath of the descendant node relative to
* this one, not including this one, WITH PREDICATES. No trailing
* slash. Wildcards may be used -
* eg: course[1]/course_name[1]
* * /course_name[1]
* (but no spaces - needed because we're in javadoc!)
*
* @return boolean true if the desendant node (ie a node in
* this node's subtree) exists at the relative xpath provided; false otherwise
*or if there is no input DOM (ie if we're
* generating UI from a non-inferred schema doc.)
*/
public boolean isDOMNodePresentAtRelXPath(String relXPath) {
log.debug("\n\n*** isDOMNodePresentAtRelXPath() got relXPath: " + relXPath
+ "\n***\n\n");
Node inputDOMRootNode = UIGenController.getInstance().getInputDOMRootNode();
if (inputDOMRootNode == null) {
log.warn("isDOMNodePresentAtRelXPath(): there is no input DOM \n"
+ "(are you generating a UI from a non-inferred schema doc?)");
return false;
}
String xpath = getFullSearchXPath(relXPath);
if (xpath == null)return false;
NodeList nList = null;
try {
nList = XMLUtilities.getNodeListWithXPath(inputDOMRootNode, xpath);
} catch (Exception ex) {
log.error("*** Exception doing XMLUtilities.getNodeListWithXPath()" + ex);
log.error("*** xpath after processing was: " + xpath);
ex.printStackTrace();
}
int totNodes = (nList != null) ? nList.getLength() : -1;
log.debug("\n\n*** isDOMNodePresentAtRelXPath() found: "
+ totNodes + " nodes\n for relative xpath: "
+ relXPath + "\n and xpath: "
+ xpath + "\n***\n\n");
return (totNodes > 0);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// SETTER FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
private void setParentName(String path) {
for (StringTokenizer st = new StringTokenizer(path, "/");
st.hasMoreTokens();
this.parentElementName = st.nextToken()) {
//it's 2 because we've already popped another token since this loop started
if (st.countTokens() < 2)break;
}
}
/**
* sets the widget type that corresponds to this element. This comprises the
* name of the binding XML file, followed by a #, and then the binding id -
* so for example, a text box widget would be denoted as:
* "textbox_bindings.xml#character_textbox"
*
* @param type -- the widget type (name of the binding XML file, followed by a
* #, and then the binding id - eg "textbox_bindings.xml#character_textbox"
* denotes a text box widget
*/
public void setWidgetType(String type) {
this.widgetType = type;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// GETTER FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/**
* this should return the string value of the desendant node (ie a node in
* this node's subtree) at the relative xpath provided
*
* @param relXPath the (String) xpath of the descendant node relative to this
* one, not including this one, WITH PREDICATES. No trailing slash.
* eg: course[1]/course_name[1]
* @return String value of the descendent text node at the relative xpath
* provided, or null if node not found
* @throws RuleExecutionException if there is no input DOM (ie if we're
* generating UI from a non-inferred schema doc.)
*/
public String getDOMTextNodeValueAtRelXPath(String relXPath) throws
RuleExecutionException {
log.debug("\n\n*** getDOMNodeValueAtRelXPath() got relXPath: " + relXPath
+ "\n***\n\n");
Node inputDOMRootNode = UIGenController.getInstance().getInputDOMRootNode();
if (inputDOMRootNode == null) {
RuleExecutionException ex = new RuleExecutionException(
"there is no input DOM \n"
+ "(are you generating a UI from a non-inferred schema doc?)");
ex.fillInStackTrace();
throw ex;
}
String xpath = getFullSearchXPath(relXPath);
if (xpath == null)return null;
Node node = null;
try {
log.error(
"\n\n\n*** getDOMTextNodeValueAtRelXPath() getting text at xpath:"
+ xpath);
node = XMLUtilities.getTextNodeWithXPath(inputDOMRootNode, xpath);
} catch (Exception ex) {
log.error("*** Exception doing XMLUtilities.getNodeWithXPath()" + ex);
log.error("*** xpath after processing was: " + xpath);
ex.printStackTrace();
}
if (node == null)return null;
String nodeVal = node.getNodeValue();
log.debug("\n\n*** getDOMTextNodeValueAtRelXPath() found: "
+ nodeVal + " \n as node value for relative xpath: "
+ relXPath + "\n and xpath: "
+ xpath + "\n***\n\n");
return nodeVal;
}
/**
* this should return the children names and values like : --> course_name,
* xsd:string --> start_date, xsd:string for /person/course element
*
* @return OrderedMap
*/
public OrderedMap getChildrenElementTypesAsMap() {
// skeletal code
return new OrderedMap();
}
/**
* returns the element type that this class was constructed with
*
* @return elementType -- the element type for this element types are listed
* in XMLSchemaElementTypes
*/
public short getType() {
return (this.elementType);
}
public String getName() {
return this.name;
}
public String getFirstElementName() {
return this.firstSchemaElement;
}
/**
* returns the name of the parent element
*
* @return String
*/
public String getParentName() {
return this.parentElementName;
}
/**
* counts the total number of input widgets in the current UI Map
*
* @return (int) the total number of input widgets in the current UI Map
*/
public int getTotalWidgetHeight() {
if (totalWidgetHeight < 1) {
totalWidgetHeight = 0;
OrderedMap map = UIGenController.getInstance().getUIGenMap();
if (map == null) return 0;
Iterator it = map.values().iterator();
while (it.hasNext()) {
XSElementDeclarationWrapper nextWrapper
= (XSElementDeclarationWrapper) (it.next());
if (nextWrapper == null) continue;
int nextHeight = nextWrapper.getWidgetHeight();
if (nextHeight > 0) totalWidgetHeight += nextHeight;
}
}
return totalWidgetHeight;
}
/**
* assigns a page number to this widget by checking if there is room on the
* current page by looking at the running total of widget heights for the
* current page. If there is insufficient space, the widget is assigned the
* next page number
*/
public void assignPageNumber() {
XBLBinding xbl = getXBLBinding();
if (xbl==null) return;
int widgetHeight = getWidgetHeight();
if (widgetHeight < 0) return;
currentPageHeightRunningTotal += widgetHeight;
log.debug("\n\n\n ********************************"
+"\n assignPageNumber():"
+"\n currentPageNumber="+currentPageNumber
+"\n currentPageHeightRunningTotal="+currentPageHeightRunningTotal
+"\n Settings.MAX_PAGE_HEIGHT="+Settings.MAX_PAGE_HEIGHT
+"\n ******************************** \n\n\n");
if (currentPageHeightRunningTotal > Settings.MAX_PAGE_HEIGHT) {
//increment page number...
currentPageNumber++;
//reset the running total to the root container height
currentPageHeightRunningTotal = getWidgetHeight("root_container");
}
xbl.setAttribute("putOnPage", String.valueOf(currentPageNumber));
}
/**
* returns the int height of the widget associated with this wrapper , or
* -1 if no binding has yet been assigned
*
* @return the int height of the widget associated with this wrapper , or
* -1 if no binding has yet been assigned
*/
public int getWidgetHeight() {
return getWidgetHeight(this.getWidgetType());
}
/**
* returns the int height of the widget associated with the passed string, or
* -1 if no binding has yet been assigned
*
* @param widgetType widget type strign identifying the element whose haight
* is sought - for example, a text box widget would be denoted as:
* "textbox_bindings.xml#character_textbox"
*
* @return the int height of the widget associated with the passed string, or
* -1 if no binding has yet been assigned
*/
private static int getWidgetHeight(String widgetType) {
String heightStr = (String)(Settings.WIDGET_HEIGHTS_MAP.get(widgetType));
if (heightStr==null) return -1;
return Integer.parseInt(heightStr);
}
/**
* returns the widget type for this element. This comprises the
* name of the binding XML file, followed by a #, and then the binding id -
* so for example, a text box widget would be denoted as:
* "textbox_bindings.xml#character_textbox"
*
* @return widgetType -- the widget type (name of the binding XML file,
* followed by a #, and then the binding id -
* eg "textbox_bindings.xml#character_textbox" denotes a text box widget
*/
public String getWidgetType() {
return this.widgetType;
}
public int getMaxOccurs() {
return this.maxOccurs;
}
public int getMinOccurs() {
return this.minOccurs;
}
/**
* for complex elements returns either choice or sequence
* @return String -- choice or sequence
*/
public String getGroupType() {
return this.groupType;
}
/**
* Applies the system rules to this wrapper - may be called by user rules to
* apply system rules
*/
public void applySystemRules() {
PatternMatcherAdaptor.applySystemRules(this);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// UTILITIES
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
final StringBuffer xpathBuff = new StringBuffer();
//
private String getFullSearchXPath(String relXPath) {
if (relXPath == null || relXPath.trim().equals("")) {
log.error("\n\n*** getFullSearchXPath got relXPath: "
+ relXPath + " - returning NULL\n\n");
return null;
}
//ensure all predicates present. If any missing, add as [1]'s
String next = null;
xpathBuff.delete(0, xpathBuff.length());
//start with path to this element...
xpathBuff.append(this.path);
if (!this.path.endsWith("/")) xpathBuff.append("/");
relXPath = relXPath.trim();
//we already have a slash on the end of the root xpath, so need to do this:
if (relXPath.startsWith("//")
|| relXPath.startsWith("/")) relXPath = relXPath.substring(1);
StringTokenizer st = new StringTokenizer(relXPath, "/", true);
while (st.hasMoreTokens()) {
next = st.nextToken();
log.debug("\n\n*** getFullSearchXPathnext token: " + next);
if (next == null || next.trim().length() == 0)continue;
xpathBuff.append(next);
if (! (next.endsWith("]")
|| next.endsWith("*")
|| next.endsWith("/"))) xpathBuff.append("[1]");
}
log.debug("\n\n*** getFullSearchXPath got: \n relXPath: " + relXPath
+ "\n returning full xpath: " + xpathBuff.toString() + "\n\n");
return xpathBuff.toString();
}
/**
* looks for a nodelist at the xpath "baseXPath". for each node in this list,
* gets a label from the subnode identified by "labelRelXPath", and a value
* from the subnode identified by "valueRelXPath", and passes these to the xbl
* binding's setAttribute() method.
*
* @param rootXPath String the xpath of the nodes that contain the label &
* value nodes to use for populating this dropdown; for example:
* <attributeList> <attribute id="1084825287862"> ... <measurementScale>
* <nominal> <nonNumericDomain> <enumeratedDomain> <codeDefinition>
* <code>a</code> <definition>first</definition> </codeDefinition>
* <codeDefinition> <code>b</code> <definition>second</definition>
* </codeDefinition> ...etc... in this sample, the baseXPath would be:
* "//nonNumericDomain/enumeratedDomain/codeDefinition
* @param valueRelXPath String the relative xpath to the subnode that defines
* the value - in the above example this would be "code" or "definition"
* @return an array that contains the value strings
* @throws RuleExecutionException
*/
private String[] getAttributesFromSubtree(String rootXPath,
String valueRelXPath)
throws RuleExecutionException {
Node[] nodes = getNodeArrayAtXPath(rootXPath);
int tot = nodes.length;
String[] returnArray = new String[tot];
for (int i = 0; i < tot; i++) {
Node node = null;
try {
node = XMLUtilities.getTextNodeWithXPath(nodes[i], valueRelXPath);
} catch (Exception ex) {
log.error("*** Exception doing XMLUtilities.getTextNodeWithXPath()"+ex);
log.error("*** valueRelXPath was: " + valueRelXPath);
ex.printStackTrace();
}
returnArray[i] = (node==null)? "" : node.getNodeValue();
}
return returnArray;
}
/**
* looks for a nodelist at the xpath "baseXPath". for each node in this list,
* gets a label from the subnode identified by "labelRelXPath", and a value
* from the subnode identified by "displayLabelRelXPath", and passes these to
* the xbl binding's setAttribute() method.
*
* @param xbl XBLBinding the binding on which to set the values
* @param rootXPath String the xpath of the nodes that contain the label &
* value nodes to use for populating this dropdown; for example:
* <attributeList> <attribute id="1084825287862"> ... <measurementScale>
* <nominal> <nonNumericDomain> <enumeratedDomain> <codeDefinition>
* <code>a</code> <definition>first</definition> </codeDefinition>
* <codeDefinition> <code>b</code> <definition>second</definition>
* </codeDefinition> ...etc... in this sample, the rootXPath would be:
* "//nonNumericDomain/enumeratedDomain/codeDefinition
* @param displayLabelAttributeName String the attribute name used for the display
* labels. An integer will be appended, corresponding to the index of the
* node in the node list. So if the displayLabelAttributeName is "enumeration_label_",
* the first attribute set on the xbl will be called enumeration_label_1
* <em>**NOTE** that this string is not arbitrary - it *must*
* match the string expected by the XBL binding!!</em>
* @param displayLabelRelXPath String the relative xpath to the subnode that
* defines the value of each display label - in the above example this
* would be "definition"
* @param selectedValueAttributeName String the attribute name used for the
* value that is inserted into the results when that particular dropdown
* label is selected. An integer will be appended, corresponding to the
* index of the node in the node list. So if the selectedValueAttributeName
* is "enumeration_value_", the first attribute set on the xbl will be
* called enumeration_value_1, etc.
* <em>**NOTE** that this string is not arbitrary - it *must*
* match the string expected by the XBL binding!!</em>
* @param selectedValueRelXPath String the relative xpath to the subnode that
* defines the value of each display label - in the above example this
* would be "definition"
* @param orderByComparator a java.util.Comparator that will be used to sort
* attributes (specifically the The displayLabelAttribute values )before
* they are added to the binding (eg alphabetically etc).
* If comparator is null, the attributes retain the order found in the
* original document.
* @throws RuleExecutionException
*/
private void addAttributesToXBL(XBLBinding xbl,
String rootXPath,
String displayLabelAttributeName,
String displayLabelRelXPath,
String selectedValueAttributeName,
String selectedValueRelXPath,
Comparator orderByComparator)
throws RuleExecutionException {
if (displayLabelAttributeName==null
|| selectedValueAttributeName==null
|| displayLabelRelXPath==null
|| selectedValueRelXPath == null
|| displayLabelAttributeName.trim()==""
|| selectedValueAttributeName.trim()==""
|| displayLabelRelXPath.trim() == ""
|| selectedValueRelXPath.trim() == "") {
RuleExecutionException ex = new RuleExecutionException(
"addAttributesToXBL - received null or blank input ");
ex.fillInStackTrace();
throw ex;
}
String[] dspLbls = getAttributesFromSubtree(rootXPath, displayLabelRelXPath);
String[] selVals = getAttributesFromSubtree(rootXPath, selectedValueRelXPath);
String[][] labesAndValsArray = new String[dspLbls.length][2];
int arrayLength = dspLbls.length;
for (int i=0; i < arrayLength; i++) {
labesAndValsArray[i][0] = dspLbls[i];
labesAndValsArray[i][1] = selVals[i];
}
if (orderByComparator!=null) {
Arrays.sort(labesAndValsArray, orderByComparator);
}
for (int i=0; i < arrayLength; i++) {
dspLbls[i] = labesAndValsArray[i][0];
selVals[i] = labesAndValsArray[i][1];
}
int count = 0;
for (int i=0; i < arrayLength; i++) {
count++;
xbl.setAttribute(displayLabelAttributeName + count, dspLbls[i]);
xbl.setAttribute(selectedValueAttributeName + count, selVals[i]);
}
}
/**
* overrides addAttributesToXBL() - @see addAttributesToXBL() for definition
* of parameters. Keeps attributes in order found in original document
*
* @param xbl XBLBinding
* @param rootXPath String
* @param displayLabelAttributeName String
* @param displayLabelRelXPath String
* @param selectedValueAttributeName String
* @param selectedValueRelXPath String
* @throws RuleExecutionException
*/
public void addAttributesToXBLOrderAsOriginal(XBLBinding xbl,
String rootXPath,
String displayLabelAttributeName,
String displayLabelRelXPath,
String selectedValueAttributeName,
String selectedValueRelXPath)
throws RuleExecutionException {
// Collator implements the Comparator interface
Comparator comparator = null;
addAttributesToXBL(xbl, rootXPath, displayLabelAttributeName,
displayLabelRelXPath, selectedValueAttributeName,
selectedValueRelXPath, comparator);
}
/**
* overrides addAttributesToXBL() - @see addAttributesToXBL() for definition
* of parameters. Orders attributes alphabetically
*
* @param xbl XBLBinding
* @param rootXPath String
* @param displayLabelAttributeName String
* @param displayLabelRelXPath String
* @param selectedValueAttributeName String
* @param selectedValueRelXPath String
* @throws RuleExecutionException
*/
public void addAttributesToXBLOrderByAlpha(XBLBinding xbl,
String rootXPath,
String displayLabelAttributeName,
String displayLabelRelXPath,
String selectedValueAttributeName,
String selectedValueRelXPath)
throws RuleExecutionException {
// Collator implements the Comparator interface
Comparator usCollator = new USCollator();
addAttributesToXBL(xbl, rootXPath, displayLabelAttributeName,
displayLabelRelXPath, selectedValueAttributeName,
selectedValueRelXPath, usCollator);
}
/**
* looks for a nodelist at the xpath "baseXPath". for each node in this list,
* gets a label from the subnode identified by "labelRelXPath", and a value
* from the subnode identified by "displayLabelRelXPath", and passes these to
* the xbl binding's setAttribute() method.
*
* @param xbl XBLBinding the binding on which to set the values
* @param rootXPath String the xpath of the nodes that contain the label &
* value nodes to use for populating this dropdown; for example:
* <attributeList> <attribute id="1084825287862"> ...
* <measurementScale> <nominal> <nonNumericDomain>
* <enumeratedDomain> <codeDefinition>
* <code>a</code> <definition>first</definition>
* </codeDefinition> <codeDefinition>
* <code>b</code> <definition>second</definition>
* </codeDefinition> ...etc... in this sample, the rootXPath would
* be: "//nonNumericDomain/enumeratedDomain/codeDefinition
* @param displayLabelAttributeName String the attribute name used for the
* display labels. An integer will be appended, corresponding to the index
* of the node in the node list. So if the displayLabelAttributeName is
* "enumeration_label_", the first attribute set on the xbl will be called
* enumeration_label_1 <em>**NOTE** that this string is not arbitrary - it
* *must* match the string expected by the XBL binding!!</em>
* @param displayLabelRelXPath String the relative xpath to the subnode that
* defines the value of each display label - in the above example this
* would be "definition"
* @throws RuleExecutionException
*/
public void addAttributesToXBL(XBLBinding xbl,
String rootXPath,
String displayLabelAttributeName,
String displayLabelRelXPath)
throws RuleExecutionException {
if (displayLabelAttributeName==null
|| displayLabelAttributeName.trim()=="") return;
String[] dspLbls = getAttributesFromSubtree(rootXPath, displayLabelRelXPath);
for (int i=0; i < dspLbls.length; i++) {
xbl.setAttribute(displayLabelAttributeName + (1 + i), dspLbls[i]);
}
}
/**
* looks for a nodelist at the xpath "baseXPath", and returns an array
* containing all the nodes in the nodelist
*
* @param baseXPath String the xpath of the nodes that contain the label &
* value nodes to use for populating this dropdown; for example:
* <attributeList> <attribute id="1084825287862"> ... <measurementScale>
* <nominal> <nonNumericDomain> <enumeratedDomain> <codeDefinition>
* <code>a</code> <definition>first</definition> </codeDefinition>
* <codeDefinition> <code>b</code> <definition>second</definition>
* </codeDefinition> ...etc... in this sample, the baseXPath would be:
* "//nonNumericDomain/enumeratedDomain/codeDefinition
* @return Node[] an array containing all the nodes in the nodelist
* @throws RuleExecutionException
*/
public Node[] getNodeArrayAtXPath(String baseXPath)
throws RuleExecutionException {
Node inputDOMRootNode = UIGenController.getInstance().getInputDOMRootNode();
if (inputDOMRootNode == null) {
RuleExecutionException ex = new RuleExecutionException(
"there is no input DOM \n"
+ "(are you generating a UI from a non-inferred schema doc?)");
ex.fillInStackTrace();
throw ex;
}
String xpath = this.getFullSearchXPath(baseXPath);
//remove last predicate
xpath = xpath.substring(0, xpath.lastIndexOf("[1]"));
Node[] nodes = null;
try {
nodes = XMLUtilities.getNodeListAsNodeArray(
XMLUtilities.getNodeListWithXPath(inputDOMRootNode, xpath));
} catch (TransformerException ex1) {
log.error("*** Exception doing XMLUtilities.getNodeListWithXPath()" + ex1);
log.error("*** xpath after processing was: " + xpath);
ex1.printStackTrace();
nodes = new Node[0];
}
log.debug("\n\ngetNodeArrayAtXPath() found " + nodes.length + " nodes");
return nodes;
}
public static void log(String message) {
log.debug("DROOLS: " + message);
}
}
/**
* <p>Description: </p>
* Expects o1 and o2 to be 2-element arrays; takes the first element
* (ie index=0) of each, and passes these to Collator for comparison
*/
class USCollator implements Comparator {
Collator usCollator;
private Logger log = Logger.getLogger(XSElementDeclarationWrapper.class.getName());
USCollator() {
usCollator = Collator.getInstance(Locale.US);
//next line tells comparator to ignore case, so "abc"=="ABC"
usCollator.setStrength(Collator.PRIMARY);
}
/**
* Expects o1 and o2 to be 2-element arrays; takes the first element
* (ie index=0) of each, and passes these to Collator for comparison
*
* @param o1 Object that can be cast to a 2-element array. First element
* (index=0) then compared to first element from o2
* @param o2 Object that can be cast to a 2-element array. First element
* (index=0) then compared to first element from o1
* @return int - @see java.util.comparator
*/
public int compare(Object o1, Object o2) {
String[] strArr1 = (String[])o1;
String[] strArr2 = (String[])o2;
String str1 = strArr1[0];
String str2 = strArr2[0];
log.debug("USCollator - comparing str1 = "+str1+" and str2 = "+str2);
CollationKey key1 = usCollator.getCollationKey(str1);
CollationKey key2 = usCollator.getCollationKey(str2);
int returnVal = key1.compareTo(key2);
log.debug("USCollator - result is: "+returnVal);
return returnVal;
}
}
![[BACK]](/icons/back.gif){kind=icon}
Return to XSElementDeclarationWrapper.java CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [ecoinformatics] / jalama / src / edu / ucsb / nceas / jalama / generation / rulesengine / drools