/ - Diff - D-Net - D-Net project tracking tool

     package eu.dnetlib.data.collective.transformation.core.xsl;
     import java.util.LinkedList;
     import java.util.List;
     /**
      * @author jochen
+     *
      */
     public abstract class AbstractXslElement {
     	private String functionName;
     	protected List<String> attrList = new LinkedList<String>();
     	protected StringBuilder enclosedElements = new StringBuilder();
     	protected List<String> nsList = new LinkedList<String>();
     	public AbstractXslElement(String aFunctioName) {
     		this.functionName = aFunctioName;
+    	}
     	public String asXml(boolean isEmpty){
     		StringBuilder builder = new StringBuilder();
     		builder.append("<");
     		builder.append(functionName + " ");
     		for (String ns: nsList){
     			builder.append(ns + " ");
+    		}
     		for (String attr: attrList){
     			builder.append(attr);
+    		}
     		if (isEmpty){
     			builder.append("/>");
     		}else{
     			builder.append(">");
     			builder.append(enclosedElements.toString());
     			builder.append("</");
     			builder.append(functionName + ">");
+    		}
     		return builder.toString();
+    	}
     	public String asXml() {
     		return asXml(false);
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.core.schema;
     import java.util.LinkedList;
     import java.util.List;
     /**
      * @author jochen
+     *
      */
     public class SchemaElement {
     	private String targetNamespace;
     	private String name;
     	private boolean isRepeatable;
     	private boolean isRoot;
     	private boolean containsSimpleType;
     	private int minOccurs;
     	private int maxOccurs;
     	private List<SchemaElement> childList = new LinkedList<SchemaElement>();
     	private List<SchemaAttribute> attributeList = new LinkedList<SchemaAttribute>();
     	private Namespace namespace;
     	/**
     	 * @return the targetNamespace
     	 */
     	public String getTargetNamespace() {
     		return targetNamespace;
+    	}
     	/**
     	 * @param targetNamespace the targetNamespace to set
     	 */
     	public void setTargetNamespace(String targetNamespace) {
     		this.targetNamespace = targetNamespace;
+    	}
     	/**
     	 * @return the isRepeatable
     	 */
     	public boolean isRepeatable() {
     		return isRepeatable;
+    	}
     	/**
     	 * @param isRepeatable the isRepeatable to set
     	 */
     	public void setRepeatable(boolean isRepeatable) {
     		this.isRepeatable = isRepeatable;
+    	}
     	/**
     	 * @return the isMandatory
     	 */
     	public boolean isMandatory() {
     		if (minOccurs > 0) return true;
     		return false;
+    	}
     	/**
     	 * @return the minOccurs
     	 */
     	public int getMinOccurs() {
     		return minOccurs;
+    	}
     	/**
     	 * @param minOccurs the minOccurs to set
     	 */
     	public void setMinOccurs(int minOccurs) {
     		this.minOccurs = minOccurs;
+    	}
     	/**
     	 * @return the maxOccurs
     	 */
     	public int getMaxOccurs() {
     		return maxOccurs;
+    	}
     	/**
     	 * @param maxOccurs the maxOccurs to set
     	 */
     	public void setMaxOccurs(int maxOccurs) {
     		this.maxOccurs = maxOccurs;
+    	}
     	/**
     	 * @return the childList
     	 */
     	public List<SchemaElement> getChildList() {
     		return childList;
+    	}
     	/**
     	 * @param childList the childList to set
     	 */
     	public void setChildList(List<SchemaElement> childList) {
     		this.childList = childList;
+    	}
     	/**
     	 * @param name the name of the element to set
     	 */
     	public void setName(String name) {
     		this.name = name;
+    	}
     	/**
     	 * @return the name of this element
     	 */
     	public String getName() {
     		return name;
+    	}
     	/**
     	 * sets true if this element contains a simpleType, false else
     	 * @param containsSimpleType
     	 */
     	public void setContainsSimpleType(boolean containsSimpleType) {
     		this.containsSimpleType = containsSimpleType;
+    	}
     	/**
     	 * @return the containsSimpleType
     	 */
     	public boolean containsSimpleType() {
     		return containsSimpleType;
+    	}
     	/**
     	 * @param isRoot the isRoot to set
     	 */
     	public void setRoot(boolean isRoot) {
     		this.isRoot = isRoot;
+    	}
     	/**
     	 * @return the isRoot
     	 */
     	public boolean isRoot() {
     		return isRoot;
+    	}
     	/**
     	 * @param namespace the namespace to set
     	 */
     	public void setNamespace(Namespace namespace) {
     		this.namespace = namespace;
+    	}
     	/**
     	 * @return the namespace
     	 */
     	public Namespace getNamespace() {
     		return namespace;
+    	}
     	/**
     	 * @return the attributeList
     	 */
     	public List<SchemaAttribute> getAttributeList() {
     		return attributeList;
+    	}
     	/**
     	 * @param attributeList the attributeList to set
     	 */
     	public void addAttribute(SchemaAttribute aAttribute) {
     		this.attributeList.add(aAttribute);
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.core.xsl.ext;
     import java.io.StringReader;
     import java.io.StringWriter;
     import java.util.Collection;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.LinkedList;
     import java.util.List;
     import java.util.Map;
     import javax.xml.XMLConstants;
     import javax.xml.namespace.NamespaceContext;
     import javax.xml.parsers.DocumentBuilder;
     import javax.xml.parsers.DocumentBuilderFactory;
     import javax.xml.transform.Result;
     import javax.xml.transform.Transformer;
     import javax.xml.transform.TransformerFactory;
     import javax.xml.transform.dom.DOMSource;
     import javax.xml.transform.stream.StreamResult;
     import javax.xml.xpath.XPath;
     import javax.xml.xpath.XPathFactory;
     import net.sf.saxon.om.NodeInfo;
     import net.sf.saxon.value.AtomicValue;
     import org.apache.commons.lang.StringEscapeUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.svenson.JSONParser;
     import org.w3c.dom.Document;
     import org.w3c.dom.Node;
     import org.w3c.dom.NodeList;
     import org.w3c.dom.Text;
     import org.xml.sax.InputSource;
     import eu.dnetlib.data.collective.transformation.engine.FunctionResults;
     import eu.dnetlib.data.collective.transformation.engine.functions.Convert;
     import eu.dnetlib.data.collective.transformation.engine.functions.IdentifierExtract;
     import eu.dnetlib.data.collective.transformation.engine.functions.LookupRecord;
     import eu.dnetlib.data.collective.transformation.engine.functions.ProcessingException;
     import eu.dnetlib.data.collective.transformation.engine.functions.RegularExpression;
     import eu.dnetlib.data.collective.transformation.engine.functions.Split;
     /**
      * The class implements external XSLT functions
      * @author jochen
+     *
      */
     public class TransformationFunctionProxy {
     	@SuppressWarnings("unused")
     	private static final Log log = LogFactory.getLog(TransformationFunctionProxy.class);
     	private static TransformationFunctionProxy tf;
     	private RegularExpression regExprFunction = new RegularExpression();
     	private Convert convertFunction;
     	private IdentifierExtract identifierExtractFunction = new IdentifierExtract();
     	private static DocumentBuilder docBuilder;
     	private static Transformer transformer;
     	private Split split = new Split();
     	private List<String> ignoreRecordList;
     	private Map<String, FunctionResults> mapOfResults = new HashMap<String, FunctionResults>();
     	private LookupRecord lookupRecord;
     	private static XPath xpath = XPathFactory.newInstance().newXPath();
     	/**
     	 * @return the transformationFunctionProxy instance
     	 */
     	public static TransformationFunctionProxy getInstance(){
     		if ( tf == null ){
     			tf = new TransformationFunctionProxy();
     			try {
     				DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     				dbf.setNamespaceAware(true);
     				docBuilder = dbf.newDocumentBuilder();
     				transformer  = TransformerFactory.newInstance().newTransformer();
     				xpath.setNamespaceContext(new NamespaceContext() {
     					@Override
     					public Iterator getPrefixes(String namespaceURI) {
     						// TODO Auto-generated method stub
     						return null;
+    					}
     					@Override
     					public String getPrefix(String namespaceURI) {
     						// TODO Auto-generated method stub
     						return null;
+    					}
     					@Override
     					public String getNamespaceURI(String aPrefix) {
     						if (aPrefix == null){
     							throw new IllegalArgumentException("No prefix provided!");
     						}else if (aPrefix.equals(XMLConstants.DEFAULT_NS_PREFIX)){
     							return "http://namespace.openaire.eu";
     						}else if (aPrefix.equals("dc")){
     							return "http://purl.org/dc/elements/1.1/";
     						}else{
     							return XMLConstants.NULL_NS_URI;
+    						}
+    					}
     				});
     			} catch (Exception e) {
     				log.fatal("error while instantiating DocumentBuilderFactory, Transfomer, Xpath.namespacecontext", e);
     				throw new IllegalStateException(e);
+    			}
+    		}
     		return tf;
+    	}
     	/**
     	 * @param uniqueKey
     	 * @param i
     	 * @return
     	 */
     	public String getValue(String uniqueKey, int i){
     		if ( !mapOfResults.containsKey(uniqueKey)){
     			throw new IllegalStateException("unknown key: " + uniqueKey);
+    		}
     		return mapOfResults.get(uniqueKey).get(i);
+    	}
     	/**
     	 * @param uniqueKey
     	 * @param i
     	 * @return
     	 * @deprecated
     	 */
     //	public String convert(String uniqueKey, int i){
     //		if (mapOfResults == null){
     //			return "transformationFunctionProxy_convert not initialized";
     //		}else{
     //			if (!mapOfResults.containsKey(uniqueKey)){
     //				throw new IllegalStateException("unknown key: " + uniqueKey);
     //			}
     //			return mapOfResults.get(uniqueKey).get(i);
     //		}
     //	}
     	/**
     	 * @param uniqueKey
     	 * @param i
     	 * @param aPos
     	 * @return
     	 * @deprecated
     	 */
     //	public String convert(String uniqueKey, int i, int aPos){
     //		if (mapOfResults == null){
     //			return "transformationFunctionProxy_convert not initialized";
     //		}else{
     //			if (!mapOfResults.containsKey(uniqueKey)){
     //				throw new IllegalStateException("unknown key: " + uniqueKey);
     //			}
     //			return mapOfResults.get(uniqueKey).get(i, aPos);
     //		}
     //	}
     	/**
     	 * @param uniqueKey
     	 * @param i
     	 * @return
     	 */
     	public String extract(String uniqueKey, int i){
     		if (mapOfResults == null){
     			return "transformationFunctionProxy_extract not initialized";
     		}else{
     			if (!mapOfResults.containsKey(uniqueKey)){
     				throw new IllegalStateException("unknown key: " + uniqueKey);
+    			}
     			return mapOfResults.get(uniqueKey).get(i);
+    		}
+    	}
     	/**
      	 * normalize values given as an input value by using a vocabulary
     	 * @param aInput - the value as a String
     	 * @param aVocabularyName - the name of the vocabulary, which must be known for the vocabulary registry
     	 * @return
     	 */
     	public synchronized String convertString(String aInput, String aVocabularyName){
     		List<String> values = new LinkedList<String>();
     		values.add(aInput);
     		try {
     			log.debug("conversion input: " + aInput);
     			String conversionResult = convertFunction.executeSingleValue(aVocabularyName, values);
     			log.debug("conversion result: " + conversionResult);
     			return conversionResult;
     		} catch (ProcessingException e) {
     			log.fatal("convert failed for args 'input': " + aInput + " , 'vocabularyName': " + aVocabularyName, e);
     			throw new IllegalStateException(e);
+    		}
+    	}
     	/**
     	 * normalize values given as a NodeList by using a vocabulary
     	 * @param aInput - the input values as NodeList
     	 * @param aVocabularyName - the name of the vocabulary, which must be known for the vocabulary registry
     	 * @return
     	 */
     	public synchronized String convert(NodeList aInput, String aVocabularyName){
     		List<String> values = new LinkedList<String>();
     		getTextFromNodeList(aInput, values);
     		try {
     			return convertFunction.executeSingleValue(aVocabularyName, values);
     		} catch (ProcessingException e) {
     			throw new IllegalStateException(e);
+    		}
+    	}
     	public synchronized String convert(NodeList aInput, String aVocabularyName, String aDefaultPattern, String aFunction){
     		List<String> values = new LinkedList<String>();
     		getTextFromNodeList(aInput, values);
     		try {
     			List<String> results = convertFunction.executeFilterByParams(aVocabularyName, values, aDefaultPattern, aFunction);
     			if (results.size() > 0)
     				return results.get(0);
     			else
     				return "";
     		} catch (ProcessingException e) {
     			throw new IllegalStateException(e);
+    		}
+    	}
     	private void getTextFromNodeList(NodeList aNodeList, List<String> aTextvalues){
     		for (int i = 0; i < aNodeList.getLength(); i++){
     			Node n = aNodeList.item(i);
     			if (n.getNodeType() == Node.ELEMENT_NODE)
     				getTextFromNodeList(n.getChildNodes(), aTextvalues);
     			else if (n instanceof Text)
     				aTextvalues.add(n.getNodeValue());
+    		}
+    	}
     	/**
     	 * substitutes using regular expression
     	 * @param aInput
     	 * @param aReplacement
     	 * @param aRegularExpression
     	 * @return
     	 */
     	public synchronized String regExpr(String aInput, String aReplacement, String aRegularExpression){
     		try {
     			int lastSlash = aRegularExpression.lastIndexOf("/");
     			String trailingOptions = aRegularExpression.substring(lastSlash);
     //			log.debug("trailingOptions: " + trailingOptions);
     			int replacementSlash = aRegularExpression.substring(0, lastSlash).lastIndexOf("/");
     			String replacementFromExpression = aRegularExpression.substring(replacementSlash + 1, lastSlash);
     //			log.debug("replacementFromExpr lengt: " + replacementFromExpression.length() + ", value: " + replacementFromExpression);
     			String newRegExpr = aRegularExpression.substring(0, replacementSlash + 1) + aReplacement + replacementFromExpression + trailingOptions;
     //			log.debug("newRegExpr: " + newRegExpr);
     			return regExprFunction.executeSingleValue(newRegExpr, aInput, aReplacement);
     		} catch (ProcessingException e) {
     			throw new IllegalStateException(e);
+    		}
+    	}
     	public String lookup(String aIdentifier, String aPropertyKey){
     		log.debug("functionProxy.lookup: param identifier: " + aIdentifier + " , key: " + aPropertyKey);
     		return this.lookupRecord.getPropertyValue(aIdentifier, aPropertyKey);
+    	}
     	public synchronized Collection<String> split(NodeList aInput, String aRegularExpression, String aCallId){
     		try {
     			List<String> textValues = new LinkedList<String>();
     			getTextFromNodeList(aInput, textValues);
     			return split.executeAllValues(textValues, aRegularExpression);
     			//return split.executeSingleValue(textValues, aRegularExpression, aCallId);
     		}catch (ProcessingException e){
     			throw new IllegalStateException(e);
+    		}
+    	}
     	public synchronized String split(String aCallId){
     		try {
     			return split.executeSingleValue(aCallId);
     		}catch (ProcessingException e){
     			throw new IllegalStateException(e);
+    		}
+    	}
     	/**
     	 * extract content that match pattern given by a regular expression from a given node
     	 * @param xpathExprJson
     	 * @param aInput
     	 * @param aRegExpression
     	 * @return nodeList
     	 */
     	public synchronized NodeList identifierExtract(String aXpathExprJson, Node aInput, String aRegExpression){
     		String xpathExprJson = StringEscapeUtils.unescapeXml(aXpathExprJson);
     		log.debug("unescape xpathExprJson: " + xpathExprJson);
     		String regExpression = StringEscapeUtils.unescapeXml(aRegExpression);
     		log.debug("unescape regExpr" + regExpression);
     		try{
     			List<String> xpathExprList = JSONParser.defaultJSONParser().parse(List.class, xpathExprJson);
     			// workaround: rewrap, why ?
     			DOMSource s = new DOMSource(aInput);
     			StringWriter w = new StringWriter();
     			Result r = new StreamResult(w);
     			transformer.transform(s, r);
     			Document doc = docBuilder.parse(new InputSource(new StringReader(w.toString())));
     			return identifierExtractFunction.extract(xpathExprList, doc, regExpression, docBuilder.newDocument(), xpath);
     		}catch(Exception e){
     			log.fatal("identifierExtract failed for node value: " + aInput.getNodeValue(), e);
     			throw new IllegalStateException(e.getMessage());
+    		}
+    	}
     //	public String regExpr(String uniqueKey, int i){
     //		if ( !mapOfResults.containsKey(uniqueKey)){
     //			throw new IllegalStateException("unknown key: " + uniqueKey);
     //		}
     //		return mapOfResults.get(uniqueKey).get(i);
     //	}
     	/**
     	 * add record identified by 'aIndex' to the list of records to be skipped
     	 * @param aIndex the index of the record in the object record list
     	 * @return
     	 */
     	public String skipRecord(int aIndex){
     		this.ignoreRecordList.add("" + aIndex);
     		return "";
+    	}
     	/**
     	 * @param key
     	 * @param resultsFunction_getvalue
     	 */
     	public void setResults(String key, FunctionResults resultsFunction_getvalue) {
     		mapOfResults.put(key, resultsFunction_getvalue);
+    	}
     	/**
     	 * @param ignoreRecordList the ignoreRecordList to set
     	 */
     	public void setIgnoreRecordList(List<String> ignoreRecordList) {
     		this.ignoreRecordList = ignoreRecordList;
+    	}
     	/**
     	 * @return the ignoreRecordList
     	 */
     	public List<String> getIgnoreRecordList() {
     		return ignoreRecordList;
+    	}
     	/**
     	 * @param convertFunction the convertFunction to set
     	 */
     	public void setConvertFunction(Convert convertFunction) {
     		this.convertFunction = convertFunction;
+    	}
     	/**
     	 * @return the convertFunction
     	 */
     	public Convert getConvertFunction() {
     		return convertFunction;
+    	}
     	/**
     	 * @return the lookupRecord
     	 */
     	public LookupRecord getLookupRecord() {
     		return lookupRecord;
+    	}
     	/**
     	 * @param lookupRecord the lookupRecord to set
     	 */
     	public void setLookupRecord(LookupRecord lookupRecord) {
     		this.lookupRecord = lookupRecord;
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.rulelanguage.visitor;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyAssign;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyAttribute;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyOp;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTStart;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.FtScriptVisitor;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.SimpleNode;
     public abstract class AbstractVisitor implements FtScriptVisitor {
     	/* (non-Javadoc)
     	 * @see examples.jjtree.FtScriptVisitor#visit(examples.jjtree.ASTMyAssign, java.lang.Object)
     	 */
     	@Override
     	public Object visit(ASTMyAssign node, Object data) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	/* (non-Javadoc)
     	 * @see examples.jjtree.FtScriptVisitor#visit(examples.jjtree.ASTMyAttribute, java.lang.Object)
     	 */
     	@Override
     	public Object visit(ASTMyAttribute node, Object data) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	/* (non-Javadoc)
     	 * @see examples.jjtree.FtScriptVisitor#visit(examples.jjtree.ASTMyOp, java.lang.Object)
     	 */
     	@Override
     	public Object visit(ASTMyOp node, Object data) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	/* (non-Javadoc)
     	 * @see examples.jjtree.FtScriptVisitor#visit(examples.jjtree.ASTStart, java.lang.Object)
     	 */
     	@Override
     	public Object visit(ASTStart node, Object data) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	/* (non-Javadoc)
     	 * @see examples.jjtree.FtScriptVisitor#visit(examples.jjtree.SimpleNode, java.lang.Object)
     	 */
     	@Override
     	public Object visit(SimpleNode node, Object data) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
+    }

     /* Generated By:JJTree: Do not edit this line. ASTMySet.java Version 4.3 */
     /* JavaCCOptions:MULTI=true,NODE_USES_PARSER=false,VISITOR=true,TRACK_TOKENS=false,NODE_PREFIX=AST,NODE_EXTENDS=,NODE_FACTORY=,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
     package eu.dnetlib.data.collective.transformation.rulelanguage.parser;
     import java.util.LinkedList;
     import java.util.List;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import eu.dnetlib.data.collective.transformation.rulelanguage.Rules;
     /**
      * This class is primarily designed to assign values to the element and attributes of the element
      * @author jochen
+     *
      */
     public class ASTMySet extends AbstractNode {
     	private static final Log log = LogFactory.getLog(ASTMySet.class);
     	private List<Rules> rulesList = new LinkedList<Rules>();
     	private String expressionValue;
     	private String constValue;
     	private boolean isExpressionValue = false;
       public ASTMySet(int id) {
         super(id);
+      }
       public ASTMySet(FtScript p, int id) {
         super(p, id);
+      }
       /** Accept the visitor. **/
       public Object jjtAccept(FtScriptVisitor visitor, Object data) {
         return visitor.visit(this, data);
+      }
       public void addAttributeRule(Rules aRule){
     	  log.debug("called method:  ASTMySet.addRule " + aRule.getUniqueName()+
     			  " attribute: " + aRule.getAttribute() + " defines variable?: " + aRule.definesVariable());
     	  rulesList.add(aRule);
+      }
       public List<Rules> getRules(){
     	  return this.rulesList;
+      }
       public void setValueExpression(String aExpression) {
     	  log.debug("expression: " + aExpression);
     	this.expressionValue = aExpression;
     	this.isExpressionValue = true;
+      }
       public String getValueExpression(){
     	  return this.expressionValue;
+      }
       public boolean isValueExpression(){
     	  return this.isExpressionValue;
+      }
       public void setAttribute(String aValue) {
     	  this.constValue = aValue;
+      }
+    }
     /* JavaCC - OriginalChecksum=1a796456845c74ed0ee62389483ce5a7 (do not edit this line) */

     package eu.dnetlib.data.collective.transformation.core.schema.visitor;
     import java.util.LinkedList;
     import java.util.List;
     import org.apache.commons.lang.NotImplementedException;
     //import org.apache.commons.logging.Log;
     //import org.apache.commons.logging.LogFactory;
     import com.sun.xml.xsom.XSAnnotation;
     import com.sun.xml.xsom.XSAttGroupDecl;
     import com.sun.xml.xsom.XSAttributeDecl;
     import com.sun.xml.xsom.XSAttributeUse;
     import com.sun.xml.xsom.XSComplexType;
     import com.sun.xml.xsom.XSContentType;
     import com.sun.xml.xsom.XSElementDecl;
     import com.sun.xml.xsom.XSFacet;
     import com.sun.xml.xsom.XSIdentityConstraint;
     import com.sun.xml.xsom.XSModelGroup;
     import com.sun.xml.xsom.XSModelGroupDecl;
     import com.sun.xml.xsom.XSNotation;
     import com.sun.xml.xsom.XSParticle;
     import com.sun.xml.xsom.XSSchema;
     import com.sun.xml.xsom.XSSimpleType;
     import com.sun.xml.xsom.XSType;
     import com.sun.xml.xsom.XSWildcard;
     import com.sun.xml.xsom.XSXPath;
     import com.sun.xml.xsom.visitor.XSVisitor;
     import eu.dnetlib.data.collective.transformation.core.schema.SchemaAttribute;
     import eu.dnetlib.data.collective.transformation.core.schema.SchemaElement;
     /**
      * @author jochen
+     *
      */
     public class Visitor implements XSVisitor {
     	//private static Log log = LogFactory.getLog(Visitor.class);
     	List<SchemaElement> schemaElements = new LinkedList<SchemaElement>();
     	SchemaElement currentElement;
     	SchemaAttribute currentAttribute;
     	@Override
     	public void annotation(XSAnnotation arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void attGroupDecl(XSAttGroupDecl arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void attributeDecl(XSAttributeDecl aAttributeDecl) {
     		currentAttribute.setName(aAttributeDecl.getName());
     		//log.debug("visit attribute name: " + aAttributeDecl.getName());
     		//log.debug("visit attribute type: " + aAttributeDecl.getType());
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void attributeUse(XSAttributeUse aAttributeUse) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void complexType(XSComplexType aType) {
     		if (aType.getDerivationMethod()== XSType.RESTRICTION){
     			XSContentTypeVisitorImpl contentTypeVisitor = new XSContentTypeVisitorImpl();
     			contentTypeVisitor.setVisitor(this);
     			aType.getContentType().visit(contentTypeVisitor);
     		}else{
     			// aType.getExplicitContent().visit(this);
     			throw new NotImplementedException("visiting types other then 'RESTRICTION are not implemented'");
+    		}
+    	}
     	@Override
     	public void facet(XSFacet arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void identityConstraint(XSIdentityConstraint arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void notation(XSNotation arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void schema(XSSchema arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void xpath(XSXPath arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void elementDecl(XSElementDecl aElementDecl) {
     		XSType type = aElementDecl.getType();
     		if (type.isLocal()){
     			// complete infos about the current element
     			// log.debug("visitor element name: " + aElementDecl.getName());
     			currentElement.setName(aElementDecl.getName());
     			currentElement.setTargetNamespace(aElementDecl.getTargetNamespace());
     			type.visit(this);
+    		}
+    	}
     	@Override
     	public void modelGroup(XSModelGroup aGroup) {
     		// a group of elements as childs of the root element
     		for (XSParticle p: aGroup.getChildren()){
     			particle(p);
+    		}
+    	}
     	@Override
     	public void modelGroupDecl(XSModelGroupDecl arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void wildcard(XSWildcard arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void empty(XSContentType arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void particle(XSParticle aParticle) {
     		// create a new schema element, add to the list of schema elements, set this element as current element
     		SchemaElement element = new SchemaElement();
     		element.setMinOccurs(aParticle.getMinOccurs().intValue());
     		element.setMaxOccurs(aParticle.getMaxOccurs().intValue());
     		element.setRepeatable(aParticle.isRepeated());
     		schemaElements.add(element);
     		currentElement = element;
     		XSTermVisitorImpl termVisitor = new XSTermVisitorImpl();
     		termVisitor.setVisitor(this);
     		aParticle.getTerm().visit(termVisitor);
+    	}
     	@Override
     	public void simpleType(XSSimpleType arg0) {
     		throw new NotImplementedException();
+    	}
     	public List<SchemaElement> getElements(){
     		return this.schemaElements;
+    	}
     	protected SchemaElement getCurrentElement(){
     		return currentElement;
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.core.schema.visitor;
     import org.apache.commons.lang.NotImplementedException;
     import com.sun.xml.xsom.XSElementDecl;
     import com.sun.xml.xsom.XSModelGroup;
     import com.sun.xml.xsom.XSModelGroupDecl;
     import com.sun.xml.xsom.XSParticle;
     import com.sun.xml.xsom.XSWildcard;
     import com.sun.xml.xsom.visitor.XSTermVisitor;
     /**
      * @author jochen
+     *
      */
     public class XSTermVisitorImpl implements XSTermVisitor {
     	private Visitor visitor;
     	@Override
     	public void elementDecl(XSElementDecl aElementDecl) {
     		if (aElementDecl.isLocal()){
     			  this.visitor.elementDecl(aElementDecl);
     		}else{
     			// ignore non local element declarations
+    		}
+    	}
     	@Override
     	public void modelGroup(XSModelGroup aModelGroup) {
     		XSContentTypeVisitorImpl contentTypeVisitor = new XSContentTypeVisitorImpl();
     		contentTypeVisitor.setVisitor(this.visitor);
     		for (XSParticle p: aModelGroup.getChildren()){
     			contentTypeVisitor.particle(p);
+    		}
+    	}
     	@Override
     	public void modelGroupDecl(XSModelGroupDecl arg0) {
     		throw new NotImplementedException();
+    	}
     	@Override
     	public void wildcard(XSWildcard arg0) {
     		throw new NotImplementedException();
+    	}
     	public void setVisitor(Visitor visitor) {
     		this.visitor = visitor;
+    	}
     	public Visitor getVisitor() {
     		return visitor;
+    	}
+    }

     <?xml version="1.0" ?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     	<parent>
     		<groupId>eu.dnetlib</groupId>
     		<artifactId>dnet-parent</artifactId>
     		<version>1.0.0</version>
     	</parent>
     	<modelVersion>4.0.0</modelVersion>
     	<groupId>eu.dnetlib</groupId>
     	<artifactId>unibi-data-collective-transformation-common</artifactId>
     	<packaging>jar</packaging>
     	<version>1.0.0</version>
     	<scm>
     	  <developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/unibi-data-collective-transformation-common/tags/unibi-data-collective-transformation-common-1.0.0</developerConnection>
     	</scm>
     	<dependencies>
     		<dependency>
     			<groupId>commons-beanutils</groupId>
     			<artifactId>commons-beanutils</artifactId>
     			<version>1.8.3</version>
     		</dependency>
     		<dependency>
     			<groupId>junit</groupId>
     			<artifactId>junit</artifactId>
     			<version>${junit.version}</version>
     			<scope>test</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.mockito</groupId>
     			<artifactId>mockito-core</artifactId>
     			<version>1.6</version>
     			<scope>test</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.svenson</groupId>
     			<artifactId>svenson-json</artifactId>
     			<version>[1.4.0,1.5.0)</version>
     		</dependency>
     		<dependency>
     			<groupId>org.slf4j</groupId>
     			<artifactId>slf4j-api</artifactId>
     			<version>1.6.4</version>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.slf4j</groupId>
     			<artifactId>slf4j-log4j12</artifactId>
     			<version>1.6.4</version>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>com.google.guava</groupId>
     			<artifactId>guava</artifactId>
     			<version>${google.guava.version}</version>
     		</dependency>
     		<dependency>
     			<groupId>eu.dnetlib</groupId>
     			<artifactId>cnr-service-common</artifactId>
     			<version>[1.0.0,2.0.0)</version>
     		</dependency>
     		<dependency>
     			<groupId>com.sun.xsom</groupId>
     			<artifactId>xsom</artifactId>
     			<version>20110809</version>
     		</dependency>
     	</dependencies>
     </project>

     /**
+     *
      */
     package eu.dnetlib.data.collective.transformation.core.schema;
     /**
      * @author jochen
+     *
      */
     public class SchemaAttribute {
     	private String name;
     	private boolean required;
     	/**
     	 * @return the name
     	 */
     	public String getName() {
     		return name;
+    	}
     	/**
     	 * @param name the name to set
     	 */
     	public void setName(String name) {
     		this.name = name;
+    	}
     	/**
     	 * @return the required
     	 */
     	public boolean isRequired() {
     		return required;
+    	}
     	/**
     	 * @param required the required to set
     	 */
     	public void setRequired(boolean required) {
     		this.required = required;
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.rulelanguage.visitor;
     import java.util.HashMap;
     import java.util.LinkedHashMap;
     import java.util.LinkedHashSet;
     import java.util.LinkedList;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import eu.dnetlib.data.collective.transformation.rulelanguage.Argument;
     import eu.dnetlib.data.collective.transformation.rulelanguage.Condition;
     import eu.dnetlib.data.collective.transformation.rulelanguage.IRule;
     import eu.dnetlib.data.collective.transformation.rulelanguage.Rules;
     import eu.dnetlib.data.collective.transformation.rulelanguage.RulesSet;
     import eu.dnetlib.data.collective.transformation.rulelanguage.Argument.Type;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyAssign;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyAttribute;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyCondition;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyCopy;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyEmpty;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyImport;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyNs;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyOp;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyPreprocess;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyScript;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyScript.SCRIPTTYPE;
     import eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMySet;
     import eu.dnetlib.data.collective.transformation.rulelanguage.util.Converter;
     import eu.dnetlib.data.collective.transformation.rulelanguage.util.FunctionCall;
     /**
      * Implementation of the visitor pattern; maps production rules into Java data structures
      * @author jochen
+     *
      */
     public class RuleLanguageVisitor extends AbstractVisitor{
     	private static final Log log = LogFactory.getLog(RuleLanguageVisitor.class);
     	private String scriptName = "";
     	private ASTMyScript.SCRIPTTYPE scriptType;
     	private Map<String, Set<IRule>> elementMappingRules = new LinkedHashMap<String, Set<IRule>>();
     	private Map<String, IRule> variableMappingRules = new LinkedHashMap<String, IRule>();
     	private Map<String, IRule> templateMappingRules = new LinkedHashMap<String, IRule>();
     	private List<String> importedScriptList = new LinkedList<String>();
     	private List<FunctionCall> functionCallList = new LinkedList<FunctionCall>();
     	private Map<String, String> namespaceDeclMap = new HashMap<String, String>();
     	private List<Map<String, String>> preprocessingMap = new LinkedList<Map<String,String>>();
     	/**
     	 * @return the name of the rule script
     	 */
     	public String getScriptName(){
     		return this.scriptName;
+    	}
     	/**
     	 * @return the type of the script
     	 */
     	public SCRIPTTYPE getScriptType(){
     		return this.scriptType;
+    	}
     	/**
     	 * @return the mapping of all rules
     	 */
     	public Map<String, Set<IRule>> getElementMappingRules(){
     		return this.elementMappingRules;
+    	}
     	public Map<String, IRule> getVariableMappingRules(){
     		return this.variableMappingRules;
+    	}
     	public Map<String, IRule> getTemplateMappingRules(){
     		return this.templateMappingRules;
+    	}
     	/**
     	 * @return the list of function calls - this is a subset of the rule mapping
     	 */
     	public List<FunctionCall> getFunctionCalls(){
     		return this.functionCallList;
+    	}
     	/**
     	 * @return the list of scripts that are declared as import
     	 */
     	public List<String> getImportedScripts(){
     		return this.importedScriptList;
+    	}
     	/**
     	 * @return the map of name-space declarations made in the script
     	 */
     	public Map<String, String> getNamespaceDeclarations(){
     		return this.namespaceDeclMap;
+    	}
     	/**
     	 * @return the map of preprocessings (functions, parameters)
     	 */
     	public List<Map<String, String>> getPreprocessings(){
     		return this.preprocessingMap;
+    	}
     	public Object visit(ASTMyAssign node, Object data) {
     		String attrValue = "";
     		String fieldExprValue = "";
     		Rules r = node.getRule();
     		if (node.isFieldExpression()){
     			// todo e.g. convert field-expression into a xpath-expression
     			fieldExprValue = node.getFieldExpression();
     			if (fieldExprValue.startsWith("xpath:")){
     				fieldExprValue = Converter.getXpathFromXpathExpr(fieldExprValue);
     				r.setXpath(fieldExprValue);
     			}else if (fieldExprValue.startsWith("$") && !fieldExprValue.startsWith("$job.")){
     				// variable
     				log.debug("ruleLangVisitor: assign variable:" + fieldExprValue);
     				r.setAssignmentVariable(fieldExprValue);
+    			}
     		}else if (node.isAttribute()){
     			attrValue = node.getValue();
     		}else {
     			// shouldn't happen
     			attrValue = "value not defined: " + node.getValue();
+    		}
     		r.setConstant(attrValue);
     		if (r.getUniqueName().trim().length() > 0){
     			addRule(r, r.getUniqueName());
+    		}
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyCopy node, Object data) {
     		Rules r = node.getRule();
     		r.setTemplateMatch(node.getTemplateMatchName());
     		r.getProperties().setProperty("applyTemplateSelectExpression", node.getApplyTemplateSelectExpression());
     		r.getProperties().setProperty("copySelectExpression", node.getCopySelectExpression());
     		addRule(r, r.getUniqueName());
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMySet aNode, Object aData) {
     		log.debug("called method: RuleLanguageVisitor.visit(ASTMySet)");
     		// check if the outputfield is the same in rules of this production
     		Rules myRule = aNode.getRule();
     		if (aNode.isValueExpression()){
     			// todo e.g. convert field-expression into a xpath-expression
     			String exprValue = aNode.getValueExpression();
     			if (exprValue.startsWith("xpath:")){
     				exprValue = Converter.getXpathFromXpathExpr(exprValue);
     				myRule.setXpath(exprValue);
     			}else if (exprValue.startsWith("$") && !exprValue.startsWith("$job.")){
     				// variable
     				log.debug("ruleLangVisitor: assign variable:" + exprValue);
     				myRule.setAssignmentVariable(exprValue);
+    			}
+    		}
     		List<Rules> rules = aNode.getRules();
     		RulesSet set = new RulesSet();
     		//set.setPrimaryRule(rules.get(0));
     		myRule.setRulesSet(set);
     		log.debug("rulelangvisitor rule name: " + myRule.getUniqueName() + " , hasSet : " + myRule.hasSet());
     		set.getPendingRules().addAll(rules);
     		addRule(myRule, myRule.getUniqueName());
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyEmpty node, Object data) {
     		Rules r = node.getRule();
     		r.setEmpty(node.isEmpty());
     		addRule(r, r.getUniqueName());
     		return null;
+    	}
     	/**
     	 * vist a production rule that is defined as an operation or external function call
     	 * @see eu.dnetlib.data.collective.transformation.rulelanguage.visitor.AbstractVisitor#visit(eu.dnetlib.data.collective.transformation.rulelanguage.parser.ASTMyOp, java.lang.Object)
     	 */
     	public Object visit(ASTMyOp node, Object data) {
     		Rules r = node.getRule();
     		r.setFunctionCall(node.createFunctionCall(r.isStatic()));
     		functionCallList.add(r.getFunctionCall());
     		log.debug("fc name: " + r.getFunctionCall().getExternalFunctionName());
     		for(int i =0; i < node.jjtGetNumChildren(); i++) {
                 ASTMyAttribute sn = (ASTMyAttribute)node.jjtGetChild(i);
                 Argument arg = null;
                 if (sn.getAttributeValue() != null){
                 	arg = new Argument(Type.VALUE, sn.getAttributeValue());
                 }else if (sn.getAttributeInputField() != null){
                 	if (sn.getAttributeInputField().startsWith("xpath:")){
                     	arg = new Argument(Type.INPUTFIELD, Converter.getXpathFromXpathExpr(sn.getAttributeInputField()));
                 	}else if (sn.getAttributeInputField().startsWith("$job.")){
                 		// job constant
                     	arg = new Argument(Type.JOBCONST, sn.getAttributeInputField());
                 	}else{
                 		// variable
                 		arg = new Argument(Type.VAR, sn.getAttributeInputField());
+                	}
                 }else{
                 	throw new IllegalStateException("Argument with neither value nor inputfield is not allowed.");
+                }
                 log.debug("argument: " + arg.getArgument());
                 r.getFunctionCall().addArgument(arg);
+    		}
     		if (r.getFunctionCall().getParameters() != null){
     			Set<String> keys = r.getFunctionCall().getParameters().keySet();
     			for (String key: keys){
     				log.debug("key: " + key + " , value: " + r.getFunctionCall().getParameters().get(key));
+    			}
+    		}
     		log.debug("add rule with declaration: " + r.getRuleDeclaration());
     		addRule(r, r.getUniqueName());
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyImport node, Object data) {
     		importedScriptList.add(node.getScriptName());
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyNs node, Object data) {
     		namespaceDeclMap.put(node.getNsPrefix(), node.getNsUri());
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyScript node, Object data) {
     		this.scriptName = node.getScript();
     		this.scriptType = node.getScriptType();
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyCondition node, Object data) {
     		Condition condition = new Condition();
     		if (node.getApplyExpression().length() > 0){
     			String applyExpr = Converter.getXpathFromXpathExpr(node.getApplyExpression());
     			condition.setApplyExpression(applyExpr);
+    		}
     		String conditionalExpr = Converter.getXpathFromXpathExpr(node.getConditionalExpression());
     		condition.setConditionExpression(conditionalExpr);
     		condition.setPrimaryRule(node.getPrimaryRule());
     		node.getPrimaryRule().setCondition(condition);
     		condition.setSecondaryRule(node.getSecondaryRule());
     		node.getSecondaryRule().setCondition(condition);
     		return null;
+    	}
     	@Override
     	public Object visit(ASTMyPreprocess node, Object data) {
     		Map<String, String> functionMap = new HashMap<String, String>();
     		functionMap.put(node.getFunctionName(), node.getParameter());
     		preprocessingMap.add(functionMap);
     		return null;
+    	}
     	private void addRule(IRule rule, String key){
     		log.debug("add rule with key: " + key);
     		Set<IRule> ruleSet = null;
     		if (rule.definesVariable()){
     			variableMappingRules.put(key, rule);
     		}else if (rule.definesTemplate()){
     			templateMappingRules.put(key, rule);
     		}else{
     			if (elementMappingRules.containsKey(key)){
     				ruleSet = elementMappingRules.get(key);
     			}else{
     				ruleSet = new LinkedHashSet<IRule>();
     				elementMappingRules.put(key, ruleSet);
+    			}
     			ruleSet.add(rule);
+    		}
+    	}
+    }

     package eu.dnetlib.data.collective.transformation.rulelanguage;
     import java.util.Properties;
     import eu.dnetlib.data.collective.transformation.core.schema.SchemaElement;
     import eu.dnetlib.data.collective.transformation.rulelanguage.util.FunctionCall;
     /**
      * @author jochen
+     *
      */
     public class Rules implements Comparable<Rules>, IRule{
     	public static final String staticRule = "static";
     	private String attribute = "";
     	private String targetField = "";
     	private String ruleDeclaration = "";
     	private String xpath = "";
     	private String constant = "";
     	private String namespace = "";
     	private String variable = "";
     	private String template = "";
     	private String templateMatch = "";
     	private FunctionCall funcCall;
     	private Condition condition;
     	private boolean isEmpty = false;
     	private SchemaElement targetSchemaElement;
     	private String assignmentVariable = "";
     	private RulesSet rulesSet;
     	private Properties properties = new Properties();
     	public Rules() {
+    	}
     	/**
     	 * indicates if the rule is declared as static
     	 * @return true if static, false otherwise
     	 */
     	public boolean isStatic(){
     		if (ruleDeclaration.equals(staticRule)){
     			return true;
+    		}
     		return false;
+    	}
     	/**
     	 * indicates if the rule defines a variable
     	 * @return true if variable is defined, false otherwise
     	 * @see eu.dnetlib.data.collective.transformation.rulelanguage.IRule#definesVariable()
     	 */
     	public boolean definesVariable(){
     		if (variable.length() > 0) return true;
     		return false;
+    	}
     	public boolean definesTargetField(){
     		if (targetField.length() > 0) return true;
     		return false;
+    	}
     	/**
     	 * checks if this rule defines an attribute
     	 * @return true if defines attribute else false
     	 */
     	public boolean definesAttribute(){
     		if (attribute.length() > 0) return true;
     		return false;
+    	}
     	public boolean definesTemplate(){
     		if (template.length() > 0) return true;
     		return false;
+    	}
     	@Override
     	public boolean definesTemplateMatch() {
     		if (templateMatch.length() > 0) return true;
     		return false;
+    	}
     	public void setXpath(String xpath) {
     		this.xpath = xpath;
+    	}
     	public String getXpath() {
     		return xpath;
+    	}
     	/**
     	 * sets the argument aVariable as the value of the rule
     	 * @param aVariable the variable as a reference to the value
     	 */
     	public void setAssignmentVariable(String aVariable){
     		this.assignmentVariable = aVariable;
+    	}
     	public String getAssignmentVariable(){
     		return this.assignmentVariable;
+    	}
     	public void setNamespace(String namespace) {
     		this.namespace = namespace;
+    	}

Project

General

Profile

D-Net

Revision 30622

Added by Claudio Atzori about 10 years ago