() {
+
+ private int p = 0;
+
+ /**
+ * @see java.util.Iterator#hasNext()
+ */
+ @Override
+ public boolean hasNext() {
+ return p < s.length();
+ }
+
+ /**
+ * @see java.util.Iterator#next()
+ */
+ @Override
+ public Character next() {
+ return s.charAt(p++);
+ }
+
+ /**
+ * @see java.util.Iterator#remove()
+ */
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ };
+ }
+
+ }) {
+ State newState = getState(c);
+ if (oldState != newState) {
+ if (oldState == State.NUMBER && (newState == State.IGNORED || newState == State.UNIT)) {
+ num = Integer.parseInt(s.subSequence(start, end).toString());
+ } else if (oldState == State.UNIT && (newState == State.IGNORED || newState == State.NUMBER)) {
+ out.nTimes(s.subSequence(start, end).toString(), num);
+ num = 0;
+ }
+ start = end;
+ }
+ ++end;
+ oldState = newState;
+ }
+ if (oldState == State.UNIT) {
+ out.nTimes(s.subSequence(start, end).toString(), num);
+ }
+
+ return out;
+ }
+
+ /**
+ * Parses and formats the given char sequence, preserving all data.
+ *
+ * Equivalent to eval(in).getExactly()
+ *
+ * @param in
+ * the char sequence, may not be null
+ * @return a formatted String, never null
+ */
+ public static String exactly(CharSequence in) {
+ return eval(in).getExactly();
+ }
+
+ /**
+ * Formats the given time delta, preserving all data.
+ *
+ * Equivalent to new HumanTime(in).getExactly()
+ *
+ * @param l
+ * the time delta
+ * @return a formatted String, never null
+ */
+ public static String exactly(long l) {
+ return new HumanTime(l).getExactly();
+ }
+
+ /**
+ * Parses and formats the given char sequence, potentially removing some data to make the output easier to
+ * understand.
+ *
+ * Equivalent to eval(in).getApproximately()
+ *
+ * @param in
+ * the char sequence, may not be null
+ * @return a formatted String, never null
+ */
+ public static String approximately(CharSequence in) {
+ return eval(in).getApproximately();
+ }
+
+ /**
+ * Formats the given time delta, preserving all data.
+ *
+ * Equivalent to new HumanTime(l).getApproximately()
+ *
+ * @param l
+ * the time delta
+ * @return a formatted String, never null
+ */
+ public static String approximately(long l) {
+ return new HumanTime(l).getApproximately();
+ }
+
+ /**
+ * The time delta.
+ */
+ private long delta;
+
+ /**
+ * No-argument Constructor for HumanTime.
+ *
+ * Equivalent to calling new HumanTime(0L).
+ */
+ public HumanTime() {
+ this(0L);
+ }
+
+ /**
+ * Constructor for HumanTime.
+ *
+ * @param delta
+ * the initial time delta, interpreted as a positive number
+ */
+ public HumanTime(long delta) {
+ super();
+ this.delta = Math.abs(delta);
+ }
+
+ private void nTimes(String unit, int n) {
+ if ("ms".equalsIgnoreCase(unit)) {
+ ms(n);
+ } else if ("s".equalsIgnoreCase(unit)) {
+ s(n);
+ } else if ("m".equalsIgnoreCase(unit)) {
+ m(n);
+ } else if ("h".equalsIgnoreCase(unit)) {
+ h(n);
+ } else if ("d".equalsIgnoreCase(unit)) {
+ d(n);
+ } else if ("y".equalsIgnoreCase(unit)) {
+ y(n);
+ }
+ }
+
+ private long upperCeiling(long x) {
+ return (x / 100) * (100 - CEILING_PERCENTAGE);
+ }
+
+ private long lowerCeiling(long x) {
+ return (x / 100) * CEILING_PERCENTAGE;
+ }
+
+ private String ceil(long d, long n) {
+ return Integer.toString((int) Math.ceil((double) d / n));
+ }
+
+ private String floor(long d, long n) {
+ return Integer.toString((int) Math.floor((double) d / n));
+ }
+
+ /**
+ * Adds one year to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime y() {
+ return y(1);
+ }
+
+ /**
+ * Adds n years to the time delta.
+ *
+ * @param n
+ * n
+ * @return this HumanTime object
+ */
+ public HumanTime y(int n) {
+ delta += YEAR * Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Adds one day to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime d() {
+ return d(1);
+ }
+
+ /**
+ * Adds n days to the time delta.
+ *
+ * @param n
+ * n
+ * @return this HumanTime object
+ */
+ public HumanTime d(int n) {
+ delta += DAY * Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Adds one hour to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime h() {
+ return h(1);
+ }
+
+ /**
+ * Adds n hours to the time delta.
+ *
+ * @param n
+ * n
+ * @return this HumanTime object
+ */
+ public HumanTime h(int n) {
+ delta += HOUR * Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Adds one month to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime m() {
+ return m(1);
+ }
+
+ /**
+ * Adds n months to the time delta.
+ *
+ * @param n
+ * n
+ * @return this HumanTime object
+ */
+ public HumanTime m(int n) {
+ delta += MINUTE * Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Adds one second to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime s() {
+ return s(1);
+ }
+
+ /**
+ * Adds n seconds to the time delta.
+ *
+ * @param n
+ * seconds
+ * @return this HumanTime object
+ */
+ public HumanTime s(int n) {
+ delta += SECOND * Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Adds one millisecond to the time delta.
+ *
+ * @return this HumanTime object
+ */
+ public HumanTime ms() {
+ return ms(1);
+ }
+
+ /**
+ * Adds n milliseconds to the time delta.
+ *
+ * @param n
+ * n
+ * @return this HumanTime object
+ */
+ public HumanTime ms(int n) {
+ delta += Math.abs(n);
+ return this;
+ }
+
+ /**
+ * Returns a human-formatted representation of the time delta.
+ *
+ * @return a formatted representation of the time delta, never null
+ */
+ public String getExactly() {
+ return getExactly(new StringBuilder()).toString();
+ }
+
+ /**
+ * Appends a human-formatted representation of the time delta to the given {@link Appendable} object.
+ *
+ * @param
+ * the return type
+ * @param a
+ * the Appendable object, may not be null
+ * @return the given Appendable object, never null
+ */
+ public T getExactly(T a) {
+ try {
+ boolean prependBlank = false;
+ long d = delta;
+ if (d >= YEAR) {
+ a.append(floor(d, YEAR));
+ a.append(' ');
+ a.append('y');
+ prependBlank = true;
+ }
+ d %= YEAR;
+ if (d >= DAY) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, DAY));
+ a.append(' ');
+ a.append('d');
+ prependBlank = true;
+ }
+ d %= DAY;
+ if (d >= HOUR) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, HOUR));
+ a.append(' ');
+ a.append('h');
+ prependBlank = true;
+ }
+ d %= HOUR;
+ if (d >= MINUTE) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, MINUTE));
+ a.append(' ');
+ a.append('m');
+ prependBlank = true;
+ }
+ d %= MINUTE;
+ if (d >= SECOND) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, SECOND));
+ a.append(' ');
+ a.append('s');
+ prependBlank = true;
+ }
+ d %= SECOND;
+ if (d > 0) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(Integer.toString((int) d));
+ a.append(' ');
+ a.append('m');
+ a.append('s');
+ }
+ } catch (IOException ex) {
+ // What were they thinking...
+ }
+ return a;
+ }
+
+ /**
+ * Returns an approximate, human-formatted representation of the time delta.
+ *
+ * @return a formatted representation of the time delta, never null
+ */
+ public String getApproximately() {
+ return getApproximately(new StringBuilder()).toString();
+ }
+
+ /**
+ * Appends an approximate, human-formatted representation of the time delta to the given {@link Appendable} object.
+ *
+ * @param
+ * the return type
+ * @param a
+ * the Appendable object, may not be null
+ * @return the given Appendable object, never null
+ */
+ public T getApproximately(T a) {
+
+ try {
+ int parts = 0;
+ boolean rounded = false;
+ boolean prependBlank = false;
+ long d = delta;
+ long mod = d % YEAR;
+
+ if (mod >= upperCeiling(YEAR)) {
+ a.append(ceil(d, YEAR));
+ a.append(' ');
+ a.append('y');
+ ++parts;
+ rounded = true;
+ prependBlank = true;
+ } else if (d >= YEAR) {
+ a.append(floor(d, YEAR));
+ a.append(' ');
+ a.append('y');
+ ++parts;
+ rounded = mod <= lowerCeiling(YEAR);
+ prependBlank = true;
+ }
+
+ if (!rounded) {
+ d %= YEAR;
+ mod = d % DAY;
+
+ if (mod >= upperCeiling(DAY)) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(ceil(d, DAY));
+ a.append(' ');
+ a.append('d');
+ ++parts;
+ rounded = true;
+ prependBlank = true;
+ } else if (d >= DAY) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, DAY));
+ a.append(' ');
+ a.append('d');
+ ++parts;
+ rounded = mod <= lowerCeiling(DAY);
+ prependBlank = true;
+ }
+
+ if (parts < 2) {
+ d %= DAY;
+ mod = d % HOUR;
+
+ if (mod >= upperCeiling(HOUR)) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(ceil(d, HOUR));
+ a.append(' ');
+ a.append('h');
+ ++parts;
+ rounded = true;
+ prependBlank = true;
+ } else if (d >= HOUR && !rounded) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, HOUR));
+ a.append(' ');
+ a.append('h');
+ ++parts;
+ rounded = mod <= lowerCeiling(HOUR);
+ prependBlank = true;
+ }
+
+ if (parts < 2) {
+ d %= HOUR;
+ mod = d % MINUTE;
+
+ if (mod >= upperCeiling(MINUTE)) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(ceil(d, MINUTE));
+ a.append(' ');
+ a.append('m');
+ ++parts;
+ rounded = true;
+ prependBlank = true;
+ } else if (d >= MINUTE && !rounded) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, MINUTE));
+ a.append(' ');
+ a.append('m');
+ ++parts;
+ rounded = mod <= lowerCeiling(MINUTE);
+ prependBlank = true;
+ }
+
+ if (parts < 2) {
+ d %= MINUTE;
+ mod = d % SECOND;
+
+ if (mod >= upperCeiling(SECOND)) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(ceil(d, SECOND));
+ a.append(' ');
+ a.append('s');
+ ++parts;
+ rounded = true;
+ prependBlank = true;
+ } else if (d >= SECOND && !rounded) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(floor(d, SECOND));
+ a.append(' ');
+ a.append('s');
+ ++parts;
+ rounded = mod <= lowerCeiling(SECOND);
+ prependBlank = true;
+ }
+
+ if (parts < 2) {
+ d %= SECOND;
+
+ if (d > 0 && !rounded) {
+ if (prependBlank) {
+ a.append(' ');
+ }
+ a.append(Integer.toString((int) d));
+ a.append(' ');
+ a.append('m');
+ a.append('s');
+ }
+ }
+
+ }
+
+ }
+
+ }
+ }
+ } catch (IOException ex) {
+ // What were they thinking...
+ }
+
+ return a;
+ }
+
+ /**
+ * Returns the time delta.
+ *
+ * @return the time delta
+ */
+ public long getDelta() {
+ return delta;
+ }
+
+ /**
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof HumanTime)) {
+ return false;
+ }
+ return delta == ((HumanTime) obj).delta;
+ }
+
+ /**
+ * Returns a 32-bit representation of the time delta.
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return (int) (delta ^ (delta >> 32));
+ }
+
+ /**
+ * Returns a String representation of this.
+ *
+ * The output is identical to {@link #getExactly()}.
+ *
+ * @see java.lang.Object#toString()
+ * @see #getExactly()
+ * @return a String, never null
+ */
+ @Override
+ public String toString() {
+ return getExactly();
+ }
+
+ /**
+ * Compares this HumanTime to another HumanTime.
+ *
+ * @param t
+ * the other instance, may not be null
+ * @return which one is greater
+ */
+ @Override
+ public int compareTo(HumanTime t) {
+ return delta == t.delta ? 0 : (delta < t.delta ? -1 : 1);
+ }
+
+ /**
+ * Deep-clones this object.
+ *
+ * @see java.lang.Object#clone()
+ * @throws CloneNotSupportedException
+ */
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
+
+ /**
+ * @see java.io.Externalizable#readExternal(java.io.ObjectInput)
+ */
+ @Override
+ public void readExternal(ObjectInput in) throws IOException {
+ delta = in.readLong();
+ }
+
+ /**
+ * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput)
+ */
+ @Override
+ public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeLong(delta);
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/dom4j/XPathHelper.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/dom4j/XPathHelper.java
new file mode 100644
index 0000000..107f166
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/dom4j/XPathHelper.java
@@ -0,0 +1,50 @@
+package eu.dnetlib.miscutils.dom4j; // NOPMD
+
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dom4j.Document;
+import org.dom4j.DocumentException;
+import org.dom4j.Element;
+import org.dom4j.Node;
+import org.dom4j.io.SAXReader;
+
+import eu.dnetlib.miscutils.collections.TypeFilteredCollection;
+
+/**
+ * This class allows to avoid casts and unnecessary suppress warnings statements which would be necessary when using the dom4j API.
+ *
+ * @author marko
+ *
+ */
+public class XPathHelper {
+ public static Iterable selectElements(final Node base, final String xpath) {
+ @SuppressWarnings("unchecked")
+ final List children = base.selectNodes(xpath);
+ return new TypeFilteredCollection(children, Element.class);
+ }
+
+ public static Iterable selectElements(final String base, final String xpath) {
+ Document document;
+ try {
+ document = new SAXReader().read(new StringReader(base));
+ return selectElements(document, xpath);
+ } catch (DocumentException e) {
+ return new ArrayList();
+ }
+ }
+
+ public static Element selectElement(final Node base, final String xpath) {
+ for (Element el : selectElements(base, xpath))
+ return el;
+ return null;
+ }
+
+ public static Element selectElement(final String base, final String xpath) {
+ for (Element el : selectElements(base, xpath))
+ return el;
+ return null;
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/factory/Factory.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/factory/Factory.java
new file mode 100644
index 0000000..f2be086
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/factory/Factory.java
@@ -0,0 +1,17 @@
+package eu.dnetlib.miscutils.factory;
+
+/**
+ * Provides a common interface for factory objects.
+ *
+ * @author marko
+ *
+ * @param
+ */
+public interface Factory {
+ /**
+ * returns a new instance.
+ *
+ * @return
+ */
+ T newInstance();
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/CompositeUnaryFunction.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/CompositeUnaryFunction.java
new file mode 100644
index 0000000..45461cb
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/CompositeUnaryFunction.java
@@ -0,0 +1,38 @@
+package eu.dnetlib.miscutils.functional;
+
+public class CompositeUnaryFunction implements UnaryFunction {
+
+ protected transient UnaryFunction function;
+
+ public CompositeUnaryFunction(final UnaryFunction function) {
+ this.function = function;
+ }
+
+ class UnaryHelper extends CompositeUnaryFunction {
+
+ private transient final UnaryFunction comp;
+ private transient final UnaryFunction base;
+
+ public UnaryHelper(final UnaryFunction base, final UnaryFunction comp) {
+ super(null);
+
+ this.comp = comp;
+ this.base = base;
+ }
+
+ @Override
+ public T evaluate(final X arg) {
+ return base.evaluate(comp.evaluate(arg));
+ }
+ }
+
+ public CompositeUnaryFunction of(UnaryFunction comp) { // NOPMD
+ return new UnaryHelper(this, comp);
+ }
+
+ @Override
+ public T evaluate(final K arg) {
+ return function.evaluate(arg);
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/Functional.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/Functional.java
new file mode 100644
index 0000000..f09d574
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/Functional.java
@@ -0,0 +1,34 @@
+package eu.dnetlib.miscutils.functional;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * Functional helpers.
+ *
+ * @author marko
+ *
+ */
+public class Functional {
+ /**
+ * Given a class and a constructor type, return a unary function which invokes the constructor of that class.
+ *
+ * @param
+ * @param
+ * @param clazz
+ * @param argumentType
+ * @return
+ */
+ static public UnaryFunction construct(final Class clazz, final Class argumentType) {
+ return new UnaryFunction() {
+ @Override
+ public A evaluate(final B arg) {
+ try {
+ final Constructor constructor = clazz.getConstructor(new Class[] { argumentType });
+ return constructor.newInstance(arg);
+ } catch (Exception e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+ };
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/IdentityFunction.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/IdentityFunction.java
new file mode 100644
index 0000000..350393b
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/IdentityFunction.java
@@ -0,0 +1,22 @@
+package eu.dnetlib.miscutils.functional;
+
+/**
+ * Identity function
+ *
+ * @author marko
+ *
+ * @param
+ */
+public class IdentityFunction implements UnaryFunction {
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see eu.dnetlib.miscutils.functional.UnaryFunction#evaluate(java.lang.Object)
+ */
+ @Override
+ public T evaluate(final T arg) {
+ return arg;
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/ThreadSafeUnaryFunction.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/ThreadSafeUnaryFunction.java
new file mode 100644
index 0000000..073eab2
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/ThreadSafeUnaryFunction.java
@@ -0,0 +1,52 @@
+package eu.dnetlib.miscutils.functional;
+
+import eu.dnetlib.miscutils.factory.Factory;
+
+
+/**
+ * ThreadSafeUnaryFunction maintains a ThreadLocal of a UnaryFunction and
+ * delegates the application to the thread local function.
+ *
+ * @author claudio
+ *
+ * @param
+ * @param
+ */
+public class ThreadSafeUnaryFunction implements UnaryFunction {
+
+ /**
+ * ThreadLocal UnaryFunction
+ */
+ private ThreadLocal> localFunction;
+
+ /**
+ * Builds a new ThreadSafeUnaryFunction.
+ * @param localFunction
+ */
+ public ThreadSafeUnaryFunction(ThreadLocal> localFunction) {
+ super();
+ this.localFunction = localFunction;
+ }
+
+ /**
+ * Builds a new ThreadSafeUnaryFunction.
+ * @param localFunction
+ */
+ public ThreadSafeUnaryFunction(final Factory> functionFactory) {
+ super();
+ this.localFunction = new ThreadLocal>() {
+ @Override
+ protected synchronized UnaryFunction initialValue() {
+ return functionFactory.newInstance();
+ }
+ };
+ }
+
+ /**
+ * method applies the evaluation by invoking the ThreadLocal function.
+ */
+ @Override
+ public T evaluate(K arg) {
+ return localFunction.get().evaluate(arg);
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/UnaryFunction.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/UnaryFunction.java
new file mode 100644
index 0000000..63587f3
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/UnaryFunction.java
@@ -0,0 +1,12 @@
+/**
+ *
+ */
+package eu.dnetlib.miscutils.functional;
+
+/**
+ * @author marko
+ *
+ */
+public interface UnaryFunction {
+ T evaluate(K arg);
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/hash/Hashing.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/hash/Hashing.java
new file mode 100644
index 0000000..2ac2b1a
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/hash/Hashing.java
@@ -0,0 +1,20 @@
+package eu.dnetlib.miscutils.functional.hash;
+
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.codec.digest.DigestUtils;
+
+public class Hashing {
+
+ public static String md5(String s) {
+ return DigestUtils.md5Hex(s);
+ }
+
+ public static String decodeBase64(String s) {
+ return new String(Base64.decodeBase64(s.getBytes()));
+ }
+
+ public static String encodeBase64(String s) {
+ return new String(Base64.encodeBase64(s.getBytes()));
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeHtml.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeHtml.java
new file mode 100644
index 0000000..3c9ca1a
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeHtml.java
@@ -0,0 +1,12 @@
+package eu.dnetlib.miscutils.functional.string;
+
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+import org.apache.commons.lang3.StringEscapeUtils;
+
+public class EscapeHtml implements UnaryFunction {
+ @Override
+ public String evaluate(String arg) {
+ return StringEscapeUtils.escapeHtml4(arg);
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeXml.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeXml.java
new file mode 100644
index 0000000..d509cbc
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/EscapeXml.java
@@ -0,0 +1,10 @@
+package eu.dnetlib.miscutils.functional.string;
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+import org.apache.commons.lang3.StringEscapeUtils;
+
+public class EscapeXml implements UnaryFunction {
+ @Override
+ public String evaluate(String arg) {
+ return StringEscapeUtils.escapeXml11(arg);
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/FastEscapeXml.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/FastEscapeXml.java
new file mode 100644
index 0000000..9319cb8
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/FastEscapeXml.java
@@ -0,0 +1,12 @@
+package eu.dnetlib.miscutils.functional.string;
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+
+public class FastEscapeXml implements UnaryFunction {
+
+ @Override
+ public String evaluate(String arg) {
+ return "", "]]]]>") + "]]>";
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/Sanitizer.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/Sanitizer.java
new file mode 100644
index 0000000..4fa03f2
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/Sanitizer.java
@@ -0,0 +1,23 @@
+package eu.dnetlib.miscutils.functional.string;
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+
+/**
+ * Removes control characters from a string
+ *
+ * @author claudio
+ *
+ */
+public class Sanitizer implements UnaryFunction {
+
+ @Override
+ public String evaluate(String s) {
+ return sanitize(s);
+ }
+
+
+ public static String sanitize(String s) {
+ return s.replaceAll("\\p{Cntrl}", "");
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/UnescapeHtml.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/UnescapeHtml.java
new file mode 100644
index 0000000..07d9be4
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/string/UnescapeHtml.java
@@ -0,0 +1,12 @@
+package eu.dnetlib.miscutils.functional.string;
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+import org.apache.commons.lang3.StringEscapeUtils;
+
+public class UnescapeHtml implements UnaryFunction {
+
+ @Override
+ public String evaluate(final String arg) {
+ return StringEscapeUtils.unescapeHtml4(arg);
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/AbstractApplyXslt.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/AbstractApplyXslt.java
new file mode 100644
index 0000000..6243d4b
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/AbstractApplyXslt.java
@@ -0,0 +1,197 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.Map;
+
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.URIResolver;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+
+/**
+ * This function applies a stylesheet to something which can be transformed to a javax.xml.Source.
+ *
+ * Subclasses are specialized and know how to transform K into a Source
+ *
+ * @author marko
+ *
+ * @param
+ */
+public abstract class AbstractApplyXslt implements UnaryFunction {
+ private static final String UNKNOWN_XSLT_NAME = "unknown xslt name";
+
+ private static final Log log = LogFactory.getLog(AbstractApplyXslt.class); // NOPMD by marko on 11/24/08 5:02 PM
+
+ private Transformer transformer;
+
+ /**
+ * optional, useful to keep track of xslt name for debugging purposes.
+ */
+ private String xsltName;
+
+ public AbstractApplyXslt(final Resource xslt) {
+ this(xslt, null);
+ }
+
+ public AbstractApplyXslt(final Resource xslt, Map parameters) {
+ this(new StreamSource(getInputStream(xslt)), getFileName((ClassPathResource) xslt), parameters);
+ }
+
+ public AbstractApplyXslt(final String xslt) {
+ this(xslt, UNKNOWN_XSLT_NAME);
+ }
+
+ public AbstractApplyXslt(final String xslt, String name) {
+ this(xslt, name, null);
+ }
+
+ public AbstractApplyXslt(final String xslt, String name, Map parameters) {
+ this(new StreamSource(new StringReader(xslt)), name, parameters);
+ }
+
+ public AbstractApplyXslt(final Source xslt) {
+ this(xslt, UNKNOWN_XSLT_NAME);
+ }
+
+ public AbstractApplyXslt(final Source xslt, String name) {
+ this(xslt, name, null);
+ }
+
+ /**
+ * Base method for all the others.
+ * @param xslt
+ * @param name
+ * @param parameters
+ */
+ public AbstractApplyXslt(final Source xslt, String name, Map parameters) {
+ try {
+ this.xsltName = name;
+ TransformerFactory factory = TransformerFactory.newInstance();
+ if (! UNKNOWN_XSLT_NAME.equals(name))
+ factory.setURIResolver(new ExternalResourceURIResolver(name.replaceFirst("[^/]+$", "")));
+ transformer = factory.newTransformer(xslt);
+ if(parameters != null)
+ for(Map.Entry parameter : parameters.entrySet())
+ transformer.setParameter(parameter.getKey(), parameter.getValue());
+
+ } catch (final Throwable e) {
+ log.error("Problems with transformer!\n" + xslt + "--" + name, e);
+ log.error(xsltDump(xslt));
+ throw new IllegalStateException(e);
+ }
+ }
+
+ /**
+ * This class contains the login enabling imports of peer external resources for the current xslt ()
+ * The method resolve() first looks for the resource within the file system; if this fails, it looks in the classpath.
+ * @author Andrea Mannocci
+ *
+ */
+ private class ExternalResourceURIResolver implements URIResolver {
+ private final String xsltBasePath;
+
+ public ExternalResourceURIResolver(String xsltBasePath) {
+ this.xsltBasePath = xsltBasePath;
+ }
+ @Override
+ public Source resolve(String href, String base) throws TransformerException {
+ String externalResource = this.xsltBasePath + href;
+ try{
+ log.debug("trying to load external resource from file system: " + externalResource);
+ return new StreamSource(new File(externalResource));
+ } catch (final Throwable e) {
+ log.debug("trying to load external resource from file system: " + externalResource);
+ return new StreamSource(getInputStream(new ClassPathResource(externalResource)));
+ }
+ }
+ }
+
+ private String xsltDump(Source xslt) {
+ Transformer transformer;
+ try {
+ transformer = TransformerFactory.newInstance().newTransformer();
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ StringWriter outWriter = new StringWriter();
+ Result result = new StreamResult(outWriter);
+ transformer.transform(xslt, result);
+ StringBuffer sb = outWriter.getBuffer();
+ return sb.toString();
+ } catch (TransformerConfigurationException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (TransformerException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return "error dumping the xslt";
+ }
+
+ @Override
+ public String evaluate(final K input) {
+ try {
+ final StringWriter output = new StringWriter();
+ transformer.transform(toStream(input), new StreamResult(output));
+ return output.toString();
+ } catch (final TransformerException e) {
+ log.error("cannot transform record", e);
+ log.debug(input.toString());
+ return "";
+ }
+ }
+
+ public abstract Source toStream(K input);
+
+ public abstract String toString(K input);
+
+ /**
+ * Used only to convert checked to unchecked exception.
+ *
+ * @param xslt
+ * @return
+ */
+ private static InputStream getInputStream(final Resource xslt) {
+ try {
+ return xslt.getInputStream();
+ } catch (final IOException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ private static String getFileName(ClassPathResource xslt) {
+ return xslt.getPath();
+ }
+
+ public Transformer getTransformer() {
+ return transformer;
+ }
+
+ public void setTransformer(final Transformer transformer) {
+ this.transformer = transformer;
+ }
+
+ public String getXsltName() {
+ return xsltName;
+ }
+
+ public void setXsltName(String xsltName) {
+ this.xsltName = xsltName;
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXslt.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXslt.java
new file mode 100644
index 0000000..6325eb6
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXslt.java
@@ -0,0 +1,60 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.io.StringReader;
+import java.util.Map;
+
+import javax.xml.transform.Source;
+import javax.xml.transform.stream.StreamSource;
+
+import org.springframework.core.io.Resource;
+
+/**
+ * Applies a stylesheet to a XML string and returns an XML string.
+ *
+ * @author marko
+ *
+ */
+public class ApplyXslt extends AbstractApplyXslt {
+
+ public ApplyXslt(Resource xslt) {
+ super(xslt);
+ }
+
+ public ApplyXslt(Source xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXslt(Source xslt) {
+ super(xslt);
+ }
+
+ public ApplyXslt(String xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXslt(String xslt) {
+ super(xslt);
+ }
+
+ public ApplyXslt(Resource xslt, Map parameters) {
+ super(xslt, parameters);
+ }
+
+ public ApplyXslt(Source xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ public ApplyXslt(String xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ @Override
+ public Source toStream(String input) {
+ return new StreamSource(new StringReader(input));
+ }
+
+ @Override
+ public String toString(String input) {
+ return input;
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom.java
new file mode 100644
index 0000000..91fd8b5
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom.java
@@ -0,0 +1,80 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.io.StringWriter;
+import java.util.Map;
+
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.springframework.core.io.Resource;
+import org.w3c.dom.Node;
+
+/**
+ * Applies a stylesheet to a XML DOM and returns an XML string.
+ *
+ * @author marko
+ *
+ */
+public class ApplyXsltDom extends AbstractApplyXslt {
+
+ public ApplyXsltDom(Resource xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom(Source xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXsltDom(Source xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom(String xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXsltDom(String xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom(Resource xslt, Map parameters) {
+ super(xslt, parameters);
+ }
+
+ public ApplyXsltDom(Source xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ public ApplyXsltDom(String xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ @Override
+ public Source toStream(Node input) {
+ return new DOMSource(input);
+ }
+
+ @Override
+ public String toString(Node input) {
+ return nodeToString(input);
+ }
+
+ private String nodeToString(Node node) {
+ StringWriter sw = new StringWriter();
+ try {
+ Transformer t = TransformerFactory.newInstance().newTransformer();
+ t.setOutputProperty(OutputKeys.INDENT, "yes");
+ t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+ t.transform(new DOMSource(node), new StreamResult(sw));
+ } catch (TransformerException te) {
+ System.out.println("nodeToString Transformer Exception");
+ }
+ return sw.toString();
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom4j.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom4j.java
new file mode 100644
index 0000000..fdbb050
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/ApplyXsltDom4j.java
@@ -0,0 +1,61 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.util.Map;
+
+import javax.xml.transform.Source;
+
+import org.dom4j.Document;
+import org.dom4j.io.DocumentSource;
+import org.springframework.core.io.Resource;
+
+/**
+ * Applies a stylesheet to a XML DOM4j and returns an XML string.
+ *
+ * @author marko
+ *
+ */
+public class ApplyXsltDom4j extends AbstractApplyXslt {
+
+ public ApplyXsltDom4j(Resource xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom4j(Source xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXsltDom4j(Source xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom4j(String xslt, String name) {
+ super(xslt, name);
+ }
+
+ public ApplyXsltDom4j(String xslt) {
+ super(xslt);
+ }
+
+ public ApplyXsltDom4j(Resource xslt, Map parameters) {
+ super(xslt, parameters);
+ }
+
+ public ApplyXsltDom4j(Source xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ public ApplyXsltDom4j(String xslt, String name, Map parameters) {
+ super(xslt, name, parameters);
+ }
+
+ @Override
+ public Source toStream(Document input) {
+ return new DocumentSource(input);
+ }
+
+ @Override
+ public String toString(Document input) {
+ return input.asXML();
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/DnetXsltFunctions.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/DnetXsltFunctions.java
new file mode 100644
index 0000000..0e99f10
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/DnetXsltFunctions.java
@@ -0,0 +1,123 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.google.common.base.Joiner;
+import eu.dnetlib.miscutils.functional.hash.Hashing;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * This class provides some XSLT functions.
+ *
+ * ...
+ *
+ * @author michele
+ *
+ */
+public class DnetXsltFunctions {
+
+ private static final Log log = LogFactory.getLog(DnetXsltFunctions.class); // NOPMD by marko on 11/24/08 5:02 PM
+
+ private static volatile long seedUniquifier = 8682522807148012L;
+
+ private static String[] dateFormats = { "yyyy-MM-dd", "yyyy/MM/dd" };
+
+ private static final String[] normalizeDateFormats = { "yyyy-MM-dd'T'hh:mm:ss", "yyyy-MM-dd", "yyyy/MM/dd", "yyyy" };
+
+ private static final String normalizeOutFormat = new String("yyyy-MM-dd'T'hh:mm:ss'Z'");
+
+ public static String extractYear(String s) throws ParseException {
+ Calendar c = new GregorianCalendar();
+ for (String format : dateFormats) {
+ try {
+ c.setTime(new SimpleDateFormat(format).parse(s));
+ String year = String.valueOf(c.get(Calendar.YEAR));
+ return year;
+ } catch (ParseException e) {}
+ }
+ return "";
+ }
+
+ public static String normalizeDate(final String s, final boolean strict) {
+
+ final String date = s != null ? s.trim() : "";
+
+ for (String format : normalizeDateFormats) {
+ try {
+ Date parse = new SimpleDateFormat(format).parse(date);
+ String res = new SimpleDateFormat(normalizeOutFormat).format(parse);
+ return res;
+ } catch (ParseException e) {}
+ }
+ if (strict) {
+ throw new IllegalArgumentException("unable to normalize date: " + date);
+ } else {
+ //log.warn("unable to normalize date: " + s);
+ return "";
+ }
+ }
+
+ public static String randomInt(int max) {
+ return String.valueOf(new Random(++seedUniquifier + System.nanoTime()).nextInt(max));
+ }
+
+ public static String md5(String s) {
+ return Hashing.md5(s);
+ }
+
+ public static String decodeBase64(String s) {
+ return Hashing.decodeBase64(s);
+ }
+
+ public static String encodeBase64(String s) {
+ return Hashing.encodeBase64(s);
+ }
+
+ public static String lc(String s) {
+ return s.toLowerCase();
+ }
+
+ public static String uc(String s) {
+ return s.toUpperCase();
+ }
+
+ public static String decade(String s) {
+ String res = _decade(s.trim());
+ log.debug(s + "--> " + res);
+ return res;
+ }
+
+ private static String _decade(String s) {
+ Matcher m1 = Pattern.compile("(\\d\\d\\d)\\d").matcher(s);
+ if (m1.find()) {
+ String part = m1.group(1);
+ return part + "0-" + part + "9";
+ }
+ Matcher m2 = Pattern.compile("(\\d)\\d").matcher(s);
+ if (m2.find()) {
+ String part = m2.group(1);
+ return "19" + part + "0-19" + part + "9";
+ }
+ return "n/a";
+ }
+
+ public static String join(final String s1, final String separator, final String s2) {
+ if(StringUtils.isBlank(s1) || StringUtils.isBlank(s2)){
+ return "";
+ }
+ return Joiner.on(separator).join(s1, s2);
+ }
+
+ public static String pickFirst(final String s1, final String s2) {
+ return StringUtils.isNotBlank(s1) ? s1 : StringUtils.isNotBlank(s2) ? s2 : "";
+ }
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/IndentXmlString.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/IndentXmlString.java
new file mode 100644
index 0000000..df62c36
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/IndentXmlString.java
@@ -0,0 +1,133 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.io.*;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.*;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import com.sun.org.apache.xml.internal.serialize.OutputFormat;
+import com.sun.org.apache.xml.internal.serialize.XMLSerializer;
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * The Class IndentXmlString.
+ */
+public class IndentXmlString implements UnaryFunction {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see eu.dnetlib.miscutils.functional.UnaryFunction#evaluate(java.lang.Object)
+ */
+ @Override
+ public String evaluate(final String unformattedXml) {
+ try {
+ return doIndent(unformattedXml);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Do indent.
+ *
+ * @param unformattedXml
+ * the unformatted xml
+ * @return the string
+ * @throws IOException
+ * Signals that an I/O exception has occurred.
+ */
+ protected String doIndent(final String unformattedXml) throws IOException {
+ final Document document = parseXmlString(unformattedXml);
+
+ OutputFormat format = new OutputFormat(document);
+ format.setIndenting(true);
+ format.setIndent(2);
+ Writer out = new StringWriter();
+ XMLSerializer serializer = new XMLSerializer(out, format);
+ serializer.serialize(document);
+
+ return out.toString();
+ }
+
+ /**
+ * Parses the xml string.
+ *
+ * @param in
+ * the in
+ * @return the document
+ */
+ protected Document parseXmlString(final String in) {
+ try {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ db.setErrorHandler(null);
+ InputSource is = new InputSource(new StringReader(in));
+ return db.parse(is);
+ } catch (ParserConfigurationException e) {
+ throw new RuntimeException(e);
+ } catch (SAXException e) {
+ throw new RuntimeException(e);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private String doIndent(final Document document) throws TransformerException, UnsupportedEncodingException {
+
+ final Transformer transformer = getTransformer();
+ final ByteArrayOutputStream out = new ByteArrayOutputStream();
+ transformer.transform(new DOMSource(document), new StreamResult(out));
+
+ return out.toString("utf-8");
+ }
+
+ private Transformer getTransformer() throws TransformerConfigurationException {
+ TransformerFactory tf = TransformerFactory.newInstance();
+ Transformer transformer = tf.newTransformer();
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, "yes");
+ transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+ return transformer;
+ }
+
+ private Document doIndentDocument(final Document document) throws TransformerException, UnsupportedEncodingException {
+
+ final Transformer transformer = getTransformer();
+
+ final DOMResult out = new DOMResult();
+ transformer.transform(new DOMSource(document), out);
+
+ return (Document) out.getNode();
+ }
+
+ /**
+ * Static helper Apply.
+ *
+ * @param xml
+ * the xml
+ * @return the indented xml string
+ */
+ public static String apply(final String xml) {
+ return new IndentXmlString().evaluate(xml);
+ }
+
+ /**
+ * Static helper Apply.
+ *
+ * @param xml
+ * the xml
+ * @return the indented xml string
+ */
+ public static Document apply(final Document xml) throws TransformerException, UnsupportedEncodingException {
+ return new IndentXmlString().doIndentDocument(xml);
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/SerializeXml.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/SerializeXml.java
new file mode 100644
index 0000000..efa00bb
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/SerializeXml.java
@@ -0,0 +1,45 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+import java.io.StringWriter;
+
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Node;
+
+import eu.dnetlib.miscutils.functional.UnaryFunction;
+
+public class SerializeXml implements UnaryFunction {
+
+ Transformer transformer;
+
+ public SerializeXml() {
+ try {
+ this.transformer = TransformerFactory.newInstance().newTransformer();
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ } catch (TransformerConfigurationException e) {
+ throw new IllegalStateException(e);
+ } catch (TransformerFactoryConfigurationError e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public String evaluate(Node arg) {
+ StreamResult result = new StreamResult(new StringWriter());
+ DOMSource source = new DOMSource(arg);
+ try {
+ transformer.transform(source, result);
+ return result.getWriter().toString();
+ } catch (TransformerException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/TryIndentXmlString.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/TryIndentXmlString.java
new file mode 100644
index 0000000..86351c1
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/functional/xml/TryIndentXmlString.java
@@ -0,0 +1,22 @@
+package eu.dnetlib.miscutils.functional.xml;
+
+/**
+ * The Class TryIndentXmlString. Tries to indent an xml string. If an error occurs (e.g. broken xml) it returns the original xml.
+ */
+public class TryIndentXmlString extends IndentXmlString {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see eu.dnetlib.miscutils.functional.xml.IndentXmlString#evaluate(java.lang.String)
+ */
+ @Override
+ public String evaluate(final String unformattedXml) {
+ try {
+ return doIndent(unformattedXml);
+ } catch (Exception e) {
+ return unformattedXml;
+ }
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/NilTreeNode.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/NilTreeNode.java
new file mode 100644
index 0000000..3b6eb51
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/NilTreeNode.java
@@ -0,0 +1,16 @@
+package eu.dnetlib.miscutils.hstree;
+
+/**
+ * This is the terminator node in a tree definition chain:
+ *
+ * TreeNode>>
+ *
+ * Note the use of "Void" as the next-resource-parameter value in the last level.
+ *
+ *
+ * @author marko
+ *
+ */
+abstract public class NilTreeNode extends TreeNode> { // NOPMD
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/TreeNode.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/TreeNode.java
new file mode 100644
index 0000000..123ede0
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/hstree/TreeNode.java
@@ -0,0 +1,252 @@
+package eu.dnetlib.miscutils.hstree;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * This class implement statically typed complete tree of finite depth. The type signature of each tree node determines
+ * fully the depth and the types of all the children.
+ *
+ *
+ * class MyTree extends TreeNode<RootPayload, L1Payload, TreeNode<L1Payload, L2Payload, TreeNode<L2Payload, Void, NilTreeNode>>> {
+ *
+ * }
+ *
+ *
+ * However since java doesn't have type inferencing we'll have to write often the full type of intermediate nodes,
+ * especially during tree construction. Thus it's recommended that you split the chain into a number of dummy classes,
+ * serving only to the purpuse of declaring the type chain:
+ *
+ *
+ * class MyTree extends TreeNode<RootPayload, L1Payload, L1Tree> {
+ * }
+ *
+ * class L1Tree extends TreeNode<L1Payload, L2Payload, L2Tree> {
+ * }
+ *
+ * class L2Tree extends TreeNode<L2Payload, Void, NilTreeNode> {
+ * }
+ *
+ *
+ * NOTE: you could keep the whole definition inside a single file using inner classes.
+ *
+ * @author marko
+ *
+ * @param
+ * Type of the payload (or resource)
+ * @param
+ * Type of the next level payload
+ * @param
+ * Type of the next level node (another TreeNode)
+ */
+public class TreeNode> {
+
+ public static final String CHILDR_UNDER_LEAF = "cannot create children under leaf nodes";
+
+ private static final Log log = LogFactory.getLog(TreeNode.class); // NOPMD by marko on 11/24/08 5:02 PM
+
+ T resource;
+ List children = new ArrayList();
+ transient Class childNodeType = autoChildNodeType(getClass());
+
+ /**
+ * Default constructor doesn't set the payload. This is used internally to construct a node. We cannot use the
+ * TreeNode(T resource) constructor only because it would force any implementor of "alias" subclasses
+ * of TreeNode to provide a dummy implementation of the constructor calling super(resource)
+ *
+ * However the constructor is protected because users should only create objects through addChild or in
+ * alternative they should provide they own constructor ovverrides.
+ */
+ protected TreeNode() {
+ // no action
+ }
+
+ /**
+ * However the constructor is protected because users should only create objects through addChild or in
+ * alternative they should provide they own constructor ovverrides.
+ *
+ * @param resource
+ * payload
+ */
+ protected TreeNode(final T resource) {
+ this.resource = resource;
+ }
+
+ /**
+ * Call this method to add a child node.
+ *
+ * Only the payload is needed, the tree node will be constructed automatically and it will be returned.
+ *
+ *
+ * L1Child c1 = root.addChild(new L1Resource());
+ * c1.addChild(new L2Resource());
+ * c1.addChild(new L2Resource()).addChild(new L3Resource());
+ *
+ *
+ * @param resource
+ * payload
+ * @return the new node
+ */
+ @SuppressWarnings("unchecked")
+ public C addChild(final N resource) {
+ try {
+ if (childNodeType.equals(NilTreeNode.class))
+ throw new IllegalStateException(CHILDR_UNDER_LEAF);
+
+ C test;
+ try {
+ test = childNodeType.newInstance();
+ test.setResource(resource);
+ } catch (InstantiationException e) {
+ /*
+ * handle the situation when someone wants to create a one argument constructor hiding the default
+ * constructor provided by the base class. Nodes should normally be constructed using addChild but we
+ * don't want to force users to do it, and if they do it they shouldn't be punished with obscure
+ * InstantiationException caused by our evil usage of reflection. Of course we should do much more here
+ * in order to be more robust in the general case.
+ */
+ try {
+ test = (C) childNodeType.getConstructors()[0].newInstance(resource); // NOPMD
+ } catch (InvocationTargetException e1) {
+ throw new IllegalStateException(e1);
+ } catch (InstantiationException e1) {
+ throw new IllegalStateException(e1);
+ }
+ }
+
+ getChildren().add(test);
+ return test;
+ } catch (IllegalArgumentException e) {
+ throw new IllegalStateException(e);
+ } catch (SecurityException e) {
+ throw new IllegalStateException(e);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ /**
+ * This method is especially useful for leaf nodes when you want to append several children to the same parent node,
+ * without having to declare a temporary variable to hold the parent node (which could have long and ugly type)
+ *
+ * @param resource
+ * @return the parent node
+ */
+ public TreeNode appendChild(final N resource) {
+ addChild(resource);
+ return this;
+ }
+
+ /**
+ * This method applies a visitor to all nodes in a breadth first fashon
+ *
+ * Currently null payloads are skipped
+ *
+ * @see Visitor
+ * @param visitor
+ */
+ public void breadthFirst(final V visitor) {
+ final Queue> queue = new LinkedList>();
+
+ queue.add(this);
+ while (!queue.isEmpty()) {
+ final TreeNode current = queue.remove();
+ log.info("visiting " + current);
+ current.accept(visitor);
+ queue.addAll(current.getChildren());
+ }
+
+ }
+
+ /**
+ * depth first.
+ *
+ * Currently null payloads are skipped
+ *
+ * @see Visitor
+ * @param Visitor
+ */
+ public void depthFirst(final V visitor) {
+ baseDepthFirst(visitor);
+ }
+
+ public void baseDepthFirst(final V visitor) {
+ accept(visitor);
+
+ for (C el : children)
+ el.baseDepthFirst(visitor);
+ }
+
+ /**
+ * For the curious, this method takes care of retrieving the runtime type information for the tree node element
+ * declared for children nodes.
+ *
+ * Because of java type erasure, this is not strictly needed for making this kind of tree work, but it's needed if
+ * we want to enable people typing ugly long signatures and use type aliases as described in the class
+ * documentation; otherwise a cast exception would occur.
+ *
+ * Aargh, any serious language which permits type polymorphysm should have a type alias feature
+ *
+ * @param clazz
+ * the class object of this class
+ * @return the class object of the node element describing children
+ */
+ @SuppressWarnings({ "unchecked", "rawtypes"})
+ protected Class autoChildNodeType(final Class clazz) {
+
+ final Type superType = clazz.getGenericSuperclass();
+
+ if (superType instanceof ParameterizedType) {
+ final ParameterizedType paramSuperType = (ParameterizedType) superType;
+
+ int argumentIndex;
+ if (paramSuperType.getRawType() == TreeNode.class)
+ argumentIndex = 3;
+ else
+ argumentIndex = 2;
+
+
+ final Type argument = (paramSuperType).getActualTypeArguments()[argumentIndex];
+
+ return getRawType(argument);
+ } else {
+ return autoChildNodeType((Class) superType);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected X getRawType(final Type type) {
+ if (type instanceof ParameterizedType)
+ return (X) ((ParameterizedType) type).getRawType();
+ return (X) type;
+ }
+
+ public List getChildren() {
+ return children;
+ }
+
+ public void setChildren(final List children) {
+ this.children = children;
+ }
+
+ public T getResource() {
+ return resource;
+ }
+
+ public void setResource(final T resource) {
+ this.resource = resource;
+ }
+
+ public void accept(final V dummy) {
+ log.fatal("should be ovverriden");
+ }
+
+}
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterableIterator.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterableIterator.java
new file mode 100644
index 0000000..4c05cf4
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterableIterator.java
@@ -0,0 +1,24 @@
+package eu.dnetlib.miscutils.iterators;
+
+import java.util.Iterator;
+
+/**
+ * Useful if you want to quickly iterate an iterable with the new java 5 syntax.
+ *
+ * @author marko
+ *
+ * @param
+ */
+public class IterableIterator implements Iterable {
+ private Iterator iter;
+
+ public IterableIterator(Iterator iter) {
+ this.iter = iter;
+ }
+
+ @Override
+ public Iterator iterator() {
+ return iter;
+ }
+}
+
diff --git a/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterablePair.java b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterablePair.java
new file mode 100644
index 0000000..ab45ef7
--- /dev/null
+++ b/dnet-core-components/src/main/java/eu/dnetlib/miscutils/iterators/IterablePair.java
@@ -0,0 +1,21 @@
+package eu.dnetlib.miscutils.iterators;
+
+import java.util.Iterator;
+import java.util.List;
+
+import eu.dnetlib.miscutils.collections.Pair;
+
+public class IterablePair implements Iterable> {
+ private final List first;
+ private final List second;
+
+ public IterablePair(List first, List second) {
+ this.first = first;
+ this.second = second;
+ }
+
+ @Override
+ public Iterator