EDIT

/**

 * Copyright (C) 2009 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.common;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Map;

import java.util.regex.Pattern;

/**

 * Abstract Comparator for Strings which allows define substitution rules which

 * are applied to the String to be compared before the actual comparison takes

 * place. By this it is e.g. possible to influence the position of objects in sorted lists etc.

 * <p>

 * <b>Intended usage</b>: To allow maximum flexibility the property

 * {@link #setSubstitutionRules(Map)} should be set in the spring application

 * context.

 *

 * @author a.kohlbecker

 * @since 24.06.2009

 */

public abstract class AbstractStringComparator<T extends Object> implements Comparator<T> {

	protected Map<Pattern, String> substitutionRules = null;

	/**

	 * Set the private field substitutionRules. The substitutionRules consist of

	 * a regular expression as key and a string to be prepended as value.

	 */

	public void setSubstitutionRules(Map<String, String> substitutionRules) {

		this.substitutionRules = new HashMap<Pattern, String>(substitutionRules.size());

		for (String regex : substitutionRules.keySet()) {

			this.substitutionRules.put(Pattern.compile(regex), substitutionRules.get(regex));

		}

	}

	/**

	 * Applies the first matching <code>substitutionRules</code> set by

	 * {@link #setSubstitutionRules()} to the given String. A rules is applied

	 * in the following way: If the regular expression matches the given string

	 * <code>s</code> the String mapped by the regular expression is prepended

	 * to <code>s</code>.

	 *

	 * @param s

	 * @return

	 */

	protected String applySubstitutionRules(String s) {

		if (substitutionRules == null) {

			return s;

		}

		StringBuffer sb = new StringBuffer();

		for (Pattern pattern : substitutionRules.keySet()) {

			if (pattern.matcher(s).matches()) {

				sb.append(substitutionRules.get(pattern)).append(s);

				return sb.toString();

			}

		}

		return s;

	}

}

    private static final Logger logger = LogManager.getLogger(CdmUtils.class);

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

/**

 * An instance of this class represents an method result that contains 2 variables. The variables may be typified.

 *

 * @author a.mueller

 * @since 30.10.2008

 */

public class DoubleResult<S extends Object, T extends Object> {

	private static final Logger logger = LogManager.getLogger(DoubleResult.class);

	private S firstResult = null;

	private T secondResult = null;

	public DoubleResult() {

		if (logger.isDebugEnabled()){logger.debug("Constructor");}

	}

	public DoubleResult(S firstResult, T secondResult) {

		this.firstResult = firstResult;

		this.secondResult = secondResult;

	}

	public S getFirstResult() {

		return firstResult;

	}

	public void setFirstResult(S firstResult) {

		this.firstResult = firstResult;

	}

	public T getSecondResult() {

		return secondResult;

	}

	public void setSecondResult(T secondResult) {

		this.secondResult = secondResult;

	}

    public static final Logger logger = LogManager.getLogger(DynamicBatch.class);

	private static final Logger logger = LogManager.getLogger(ExcelUtils.class);

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

/**

 * @author a.mueller

 * @since 20.11.2008

 */

public class FileCopy {

	private static final Logger logger = LogManager.getLogger(FileCopy.class);

	// overwrite constants

	public static final int DO_OVERWRITE = 1;

	public static final int NO_OVERWRITE = 2;

	// default values

	private static int bufferSize = 4 * 1024;

	private static int overwrite = DO_OVERWRITE;

	/**

	 * Copies a File to another directory

	 * @param sourceFile

	 * @param destinationDirectory

	 * @param destFileName

	 * @return

	 * @throws IOException

	 */

	public static boolean copy(File sourceFile, File destinationDirectory, String destFileName)

			throws IOException {

		if (sourceFile == null){

			logger.debug("No sourcefile defined");

			throw new IOException("No sourcefile defined");

		}

		if (!sourceFile.isFile() || !sourceFile.canRead()) {

			logger.debug("Not a readable file: " + sourceFile.getName());

			throw new IOException("Not a readable file: " + sourceFile.getName());

		}

		if (destFileName == null || destFileName.equals("")){

			destFileName = sourceFile.getName();

		}

		InputStream in = new FileInputStream(sourceFile);

		copy(in, destinationDirectory, destFileName);

		if (!destinationDirectory.isDirectory()) {

			logger.warn("Not a directory: " + destinationDirectory.getName());

			return false;

		}

		File destinationFile = new File(destinationDirectory, destFileName);

		OutputStream out = new FileOutputStream(destinationFile);

		return copy(in, out);

	}

	public static boolean copy(InputStream in, File destinationDirectory, String destFileName)

			throws IOException {

		if (!destinationDirectory.isDirectory()) {

			throw new IOException("Destination is not a directory");

		}

		if (destFileName == null || destFileName.equals("")){

			throw new IOException("No destination file name specified");

		}

		File destinationFile = new File(destinationDirectory, destFileName);

		OutputStream out = new FileOutputStream(destinationFile);

		return copy(in, out);

	}

	public static boolean copy(InputStream in, OutputStream out)

			throws IOException {

		byte[] buffer = new byte[bufferSize];

		int bytesRead;

		while ((bytesRead = in.read(buffer)) >= 0) {

			out.write(buffer, 0, bytesRead);

		}

		out.close();

		in.close();

		logger.debug("File copied");

		return true;

	}

	public static boolean copy(String source, String destDirectory, String destFileName)

			throws IOException {

		File sourceFile = new File(source);

		File destinationDir = new File(destDirectory);

		return copy(sourceFile, destinationDir, destFileName);

	}

	public static boolean copy(String source, String destDirectory)

			throws IOException {

		return copy(source, destDirectory, null);

	}

	/**

	 * True if file

	 * @param file File destination

	 * @return true if data can be copied, false otherwise

	 */

	public static boolean doCopy(File file) {

		boolean exists = file.exists();

		if (overwrite == DO_OVERWRITE || !exists) {

			return true;

		} else if (overwrite == NO_OVERWRITE) {

			return false;

		} else{

			return false;

		}

	}

    public static final Logger logger = LogManager.getLogger(JvmMonitor.class);

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

/**

 * Wrapps a result object so it can be used as method parameter and changed within the method.

 * This is useful especially for simple data types like <code>Boolean</code> etc.<br>

 * Example (usage):<br><code>

 * 	public String myMethod(String oneParameter, ResultWrapper<Boolean> success){<br>

 * 	    __if (oneParameter.equals("foo")){<br>

 * 	    ____success = success.setValue(false);<br>

 * 	    ____return "Foo";<br>

 * 	__}else{<br>

 * 	____//don't change success<br>

 * 	____return "All the best";<br>

 * 	__}<br>

 * 	}

 * </code>

 * Here a String is returned but the boolean value may also be changed and it's value is useable

 * by the calling method

 *

 * @author a.mueller

 * @since 01.11.2008

 */

public class ResultWrapper<T> {

	private static final Logger logger = LogManager.getLogger(ResultWrapper.class);

	public static final ResultWrapper<Boolean> NewInstance(Boolean value){

		ResultWrapper<Boolean> result = new ResultWrapper<Boolean>();

		result.setValue(value);

		if (logger.isDebugEnabled()){logger.debug("New Instance");}

		return result;

	}

	private T object;

	public T getValue() {

		return object;

	}

	public void setValue(T value) {

		this.object = value;

	}

}

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.StringBufferInputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

/**

 * @author a.kohlbecker

 * @since 16.12.2010

 *

 */

public class StreamUtils {

	public static final Logger logger = LogManager.getLogger(StreamUtils.class);

	private static final int BUFFER_SIZE = 4096;

	/**

	 * Replaces each substring of this stream that matches the literal search sequence with the specified literal replace sequence.

	 * The replacement proceeds from the beginning of the stream to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab".

	 *

	 * @param stream

	 * @param search The sequence of char values to be replaced

	 * @param replace The replacement sequence of char values

	 * @return

	 * @throws IOException

	 *

	 */

	public static InputStream streamReplace(InputStream stream, String search,	String replace) throws IOException {

		InputStreamReader reader = new InputStreamReader(stream);

		StringBuilder strBuilder = new StringBuilder();

		char[] cbuf = new char[1024];

		int charsRead = -1;

		while ((charsRead = reader.read(cbuf)) > -1){

			strBuilder.append(cbuf, 0, charsRead);

		}

		String replacedContent = strBuilder.toString().replace(search, replace);

		StringBufferInputStream replacedStream = new StringBufferInputStream(replacedContent); //TODO replace with StringReader

		logger.debug(replacedContent);

		return replacedStream;

	}

	public static InputStream streamReplaceAll(InputStream stream, String regex, String replace) throws IOException {

		InputStreamReader reader = new InputStreamReader(stream);

		StringBuilder strBuilder = new StringBuilder();

		char[] cbuf = new char[1024];

		int charsRead = -1;

		while ((charsRead = reader.read(cbuf)) > -1){

			strBuilder.append(cbuf, 0, charsRead);

		}

		String replacedContent = strBuilder.toString().replaceAll(regex, replace);

		StringBufferInputStream replacedStream = new StringBufferInputStream(replacedContent); //TODO replace with StringReader

		logger.debug(replacedContent);

		return replacedStream;

	}

	public static String readToString(InputStream stream) throws IOException {

		InputStreamReader reader = new InputStreamReader(stream);

		StringBuilder strBuilder = new StringBuilder();

		char[] cbuf = new char[1024];

		int charsRead = -1;

		while ((charsRead = reader.read(cbuf)) > -1){

			strBuilder.append(cbuf, 0, charsRead);

		}

		return strBuilder.toString();

	}

	public static void downloadFile(URL url, String saveDir)

            throws IOException {

        HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();

        int responseCode = httpConn.getResponseCode();

        // always check HTTP response code first

        if (responseCode == HttpURLConnection.HTTP_OK) {

            String fileName = "";

            String disposition = httpConn.getHeaderField("Content-Disposition");

            if (disposition != null) {

                // extracts file name from header field

                int index = disposition.indexOf("filename=");

                if (index > 0) {

                    fileName = disposition.substring(index + 10,

                            disposition.length() - 1);

                }

            } else {

                // extracts file name from URL

                fileName = url.getFile().toString().substring(url.getFile().lastIndexOf("/") + 1,

                        url.getFile().length());

            }

            // opens input stream from the HTTP connection

            InputStream inputStream = httpConn.getInputStream();

            String saveFilePath = saveDir + File.separator + fileName;

            // opens an output stream to save into file

            FileOutputStream outputStream = new FileOutputStream(saveFilePath);

            int bytesRead = -1;

            byte[] buffer = new byte[BUFFER_SIZE];

            while ((bytesRead = inputStream.read(buffer)) != -1) {

                outputStream.write(buffer, 0, bytesRead);

            }

            outputStream.close();

            inputStream.close();

        } else {

           logger.error("No file to download. Server replied HTTP code: " + responseCode);

        }

        httpConn.disconnect();

    }

}

    private static final Logger logger = LogManager.getLogger(UriUtils.class);

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.jdom.Attribute;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.Namespace;

import org.jdom.input.SAXBuilder;

import org.jdom.output.Format;

import org.jdom.output.XMLOutputter;

public class XmlHelp {

	private static final Logger logger = LogManager.getLogger(XmlHelp.class);

	public final static Format prettyFormat = Format.getPrettyFormat();

	/**

	 * Writes the Document doc to the specified file

	 * @param doc

	 * @param path

	 * @param fileName

	 * @return true, if no error

	 *

	 * TODO throw the FileNotFoundException and handle in the calling method. That is more likely the place where you can do

	 * something about the problem

	 */

	static public boolean saveToXml(Document doc, String path, String fileName, Format format ){

		try {

			if (! fileName.endsWith(".xml")){

				fileName += ".xml";

			}

			FileOutputStream outFile = new FileOutputStream(path + File.separator + fileName);

			return saveToXml(doc, outFile, format);

		} catch (FileNotFoundException e) {

			logger.error("FileNotFoundException in saveToXml()");

			return false;

		}

	}

	/**

	 * Writes the Document doc to the specified file

	 * @param doc

	 * @param path

	 * @param fileName

	 * @return true, if no error

	 *

	 * TODO throw the IOException and handle in the calling method. That is more likely the place where you can do

	 * something about the problem

	 */

	static public boolean saveToXml(Document doc, OutputStream outStream, Format format ){

		try {

			XMLOutputter out = new XMLOutputter(format);

			out.output(doc, outStream);

			return true;

		} catch (IOException e) {

			logger.error("IOException in saveToXml()");

			return false;

		}

	}

	static public Element getFirstAttributedChild(Element parent, String elementName, String attributeName, String attributeValue){

		Namespace ns = parent.getNamespace();

		List<Element> elList = getChildren(parent, elementName, ns);

		for (Element el : elList){

			Attribute attr =  el.getAttribute(attributeName);

			if (attr != null && attr.getValue().equalsIgnoreCase(attributeValue)){

				return el;

			}

		}

		return null;

	}

	static public List<Element> getAttributedChildList(Element parent, String elementName, String attributeName){

		List<Element> resultList = new ArrayList<Element>();

		Namespace ns = parent.getNamespace();

		List<Element> elList = getChildren(parent, elementName, ns);

		for (Element el : elList){

			Attribute attr =  el.getAttribute(attributeName);

			if (attr != null){

				resultList.add(el);

			}

		}

		return resultList;

	}

	/**

	 * Returns a list of children with the given element name and with a given attribute name and

	 * a given value for this attribute.<BR>

	 * The value comparison is case insensitive.

	 * @param parent

	 * @param elementName

	 * @param attributeName

	 * @param value

	 * @return

	 */

	static public List<Element> getAttributedChildListWithValue(Element parent, String elementName, String attributeName, String value){

		List<Element> resultList = new ArrayList<Element>();

		Namespace ns = parent.getNamespace();

		List<Element> elList = getChildren(parent, elementName, ns);

		for (Element el : elList){

			Attribute attr =  el.getAttribute(attributeName);

			if (attr != null){

				if (attr.getValue().equalsIgnoreCase(value)){

					resultList.add(el);

				}

			}

		}

		return resultList;

	}

	@SuppressWarnings("unchecked")

	private static List<Element> getChildren(Element parent, String elementName,Namespace ns) {

		return parent.getChildren(elementName, ns);

	}

	public static String getChildAttributeValue(Element element, String childElementName, Namespace childElementNamespace, String childAttributeName, Namespace childAttributeNamespace){

		Element child = element.getChild(childElementName, childElementNamespace);

		if (child == null){

			return null;

		}

		Attribute childAttribute = child.getAttribute(childAttributeName, childAttributeNamespace);

		if (childAttribute == null){

			return null;

		}

		return childAttribute.getValue();

	}

	public static String getChildContent(Element element, String childElementName, Namespace childElementNamespace, String childAttributeName, Namespace childAttributeNamespace){

		Element child = element.getChild(childElementName, childElementNamespace);

		if (child == null){

			return null;

		}

		List childContent = child.getContent();

		if (childContent.isEmpty()){

			return null;

		}

		for (Object content:childContent){

			if (content instanceof Element){

				Element contentEl = (Element)content;

				if (contentEl.getName().equals(childAttributeName)){

					return contentEl.getText();

				}

			}

		}

		return null;

	}

	/**

	 * @param parent

	 * @param elementName

	 * @param attributeName

	 * @param attributeValue

	 * @return

	 */

	static public Element getOrAddChild(Element parent, String elementName, String attributeName, String attributeValue){

		Element result = null;

		if (parent != null){

			if (attributeName != null){

				result = getFirstAttributedChild(parent, elementName, attributeName, attributeValue);

			}else{

				result = parent.getChild(elementName, parent.getNamespace());

			}

			if (result == null){

				result  = new Element(elementName, parent.getNamespace());

				if (attributeName != null){

					Attribute attr = new Attribute(attributeName, attributeValue);

					result.setAttribute(attr);

				}

			}

			if (result.getParent()== null){

				parent.addContent(result);

			}

		}

		return result;

	}

	static public Element insertXmlRefProperty(Element parent, String strName, String strValue){

		Namespace ns = parent.getNamespace();

		Element property = new Element("property", ns);

		Attribute name = new Attribute("name", strName);

		property.setAttribute(name);

		Attribute value = new Attribute("value", strValue);

		property.setAttribute(value);

		parent.addContent(property);

		return  property;

	}

	static public Element insertXmlValueProperty(Element parent, String strName, String strValue){

		Namespace ns = parent.getNamespace();

		Element property = new Element("property", ns);

		Attribute name = new Attribute("name", strName);

		property.setAttribute(name);

		Attribute value = new Attribute("value", strValue);

		property.setAttribute(value);

		parent.addContent(property);

		return  property;

	}

	static public Element insertXmlBean(Element parent, String strId, String strClass){

		Namespace ns = parent.getNamespace();

		Element bean = new Element("bean", ns);

		Attribute id = new Attribute("id", strId);

		bean.setAttribute(id);

		Attribute clazz = new Attribute("class", strClass);

		bean.setAttribute(clazz);

		parent.addContent(bean);

		return  bean;

	}

	/**

	 * returns the root Element in the File xmlFile

	 * @param xmlInput

	 * @return

	 * @throws JDOMException

	 * @throws IOException

	 */

	static public  Element getRoot(InputStream xmlInput) throws JDOMException, IOException{

		SAXBuilder builder = new SAXBuilder();

		Document doc = builder.build(xmlInput);

		Element root = doc.getRootElement();

		return root;

	}

	/**

	 * returns the root Element in the File xmlFile

	 *

	 * @param xmlInput

	 * @param elementName

	 * @return

	 * TODO throw the JDOMException and the IOException and handle in the calling method. That is more likely the place where you can do

	 * something about the problem

	 */

	static public  Element getRoot(InputStream xmlInput, String elementName){

		try {

			SAXBuilder builder = new SAXBuilder();

			Document doc = builder.build(xmlInput);

			Element root = doc.getRootElement();

			if (root.getName() != elementName){

				return null;

			}else{

				return root;

			}

		} catch (JDOMException e) {

			e.printStackTrace();

			return null;

		} catch (IOException e) {

			e.printStackTrace();

			return null;

		}

	}

	/**

	 * returns the root Element in the File xmlFile

	 * @param xmlInput

	 * @return

	 *

	 * TODO throw the IOException and handle in the calling method. That is more likely the place where you can do

	 * something about the problem

	 */

	static public  Element getBeansRoot(InputStream xmlInput){

		try {

			SAXBuilder builder = new SAXBuilder();

			Document doc = builder.build(xmlInput);

			Element root = doc.getRootElement();

			if (root.getName() != "beans"){

				return null;

			}else{

				return root;

			}

		} catch (JDOMException e) {

			e.printStackTrace();

			return null;

		} catch (IOException e) {

			e.printStackTrace();

			return null;

		}

	}

	/**

	 * Gets the child element and tests if there is no other child element exists having the same name.

	 * The result is returned as a pair of thd child element and a boolean value that indicates if the

	 * elements cardinality was correct. <BR>

	 * If there is more then one child element with the child element name

	 * or if there is no such element and obligatory is <code>true</code> the second part of the result is <code>false</code>

	 * Otherwise it is <code>true</code>.

	 * @param parentElement the parent element

	 * @param childName name of the child element

	 * @param nsChild the namespace for the child element

	 * @param obligatory if <code>true</code>, return value is only <code>true</code> if exactly 1 child element with

	 * the given name exists

	 * @return

	 */

	static public DoubleResult<Element, Boolean> getSingleChildElement(Element parentElement, String childName, Namespace nsChild, boolean obligatory){

		DoubleResult<Element, Boolean> result = new DoubleResult<Element, Boolean>();

		result.setSecondResult(false);

		if (parentElement == null){

			logger.warn("Parent element is null");

			return result;

		}

		List<Element> elList = getChildren(parentElement, childName, nsChild);

		if (elList.size() > 1){

			logger.error("Multiple '" + childName + "' elements.");

			return result;

		}else if (elList.size() == 0){

			logger.info("There is no '" + childName + "' element");

			if (! obligatory){

				result.setSecondResult(true);

			}

			return result;

		}

		Element childElement = elList.get(0);

		result.setFirstResult(childElement);

		result.setSecondResult(true);

		return result;

	}

	static public Element getSingleChildElement(ResultWrapper<Boolean> success, Element parentElement, String childName, Namespace nsChild, boolean obligatory){

		if (parentElement == null){

			logger.warn("Parent element is null");

			success.setValue(false);

			return null;

		}

		List<Element> elList = getChildren(parentElement, childName, nsChild);

		if (elList.size() > 1){

			logger.error("Multiple '" + childName + "' elements.");

			success.setValue(false);

			return null;

		}else if (elList.size() == 0){

			elList = getChildren(parentElement, childName, null);

			logger.info("There is no '" + childName + "' element");

			if (obligatory){

				success.setValue(false);

			}

			return null;

		}

		Element childElement = elList.get(0);

		return childElement;

	}

	static public List<Element> getMultipleChildElement(Element parentElement, String childName, Namespace nsChild, boolean obligatory){

		if (parentElement == null){

			logger.warn("Parent element is null");

			return null;

		}

		List<Element> elList = getChildren(parentElement, childName.trim(), nsChild);

		if (elList.size() == 0){

			logger.info("There is no '" + childName + "' element");

			return null;

		}

		return elList;

	}

	public static String getChildContentAttributeValue(Element element,

			String childAttributeName, Namespace taxonNameNamespace, String childElementName,

			Namespace childElementNamespace) {

		Element child = element.getChild(childAttributeName, taxonNameNamespace);

		if (child == null){

			return null;

		}

		List childContent = child.getContent();

		if (childContent.isEmpty()){

			return null;

		}

		for (Object content:childContent){

			if (content instanceof Element){

				Element contentEl = (Element)content;

				if (contentEl == null){

					return null;

				}

				if (!(contentEl.getAttributeValue(childElementName) == null)){

					Attribute at = contentEl.getAttribute("ressource");

					if (at != null) {

                        return at.getValue();

                    }

				}

			}

		}

		return null;

	}

}