D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/cnr-misc-utils/trunk/", "deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "cnr-misc-utils"}

net.sf.saxon.TransformerFactoryImpl

package eu.dnetlib.miscutils.factory;

/**

 * Provides a common interface for factory objects. 

 * 

 * @author marko

 *

 * @param <T>

 */

public interface Factory<T> {

	/**

	 * returns a new instance.

	 * 

	 * @return

	 */

	T newInstance();

}

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.

 * 

 * <pre>

 * class MyTree extends TreeNode<RootPayload, L1Payload, TreeNode<L1Payload, L2Payload, TreeNode<L2Payload, Void, NilTreeNode>>> {

 * 

 * }

 * </pre>

 * 

 * 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:

 * 

 * <pre>

 * class MyTree extends TreeNode<RootPayload, L1Payload, L1Tree> {

 * }

 * 

 * class L1Tree extends TreeNode<L1Payload, L2Payload, L2Tree> {

 * }

 * 

 * class L2Tree extends TreeNode<L2Payload, Void, NilTreeNode> {

 * }

 * </pre>

 * 

 * NOTE: you could keep the whole definition inside a single file using inner classes.

 * 

 * @author marko

 * 

 * @param <T>

 *            Type of the payload (or resource)

 * @param <N>

 *            Type of the next level payload

 * @param <C>

 *            Type of the next level node (another TreeNode)

 */

public class TreeNode<T, N, V, C extends TreeNode<N, ?, V, ?>> {

	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<C> children = new ArrayList<C>();

	transient Class<? extends C> childNodeType = autoChildNodeType(getClass());

	/**

	 * Default constructor doesn't set the payload. This is used internally to construct a node. We cannot use the

	 * <code>TreeNode(T resource)</code> constructor only because it would force any implementor of "alias" subclasses

	 * of TreeNode to provide a dummy implementation of the constructor calling <code>super(resource)</code>

	 * 

	 * However the constructor is protected because users should only create objects through <code>addChild</code> 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 <code>addChild</code> 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.

	 * 

	 * <pre>

	 * L1Child c1 = root.addChild(new L1Resource());

	 * c1.addChild(new L2Resource());

	 * c1.addChild(new L2Resource()).addChild(new L3Resource());

	 * </pre>

	 * 

	 * @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<T, N, V, C> 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<TreeNode<?, ?, V, ?>> queue = new LinkedList<TreeNode<?, ?, V, ?>>();

		queue.add(this);

		while (!queue.isEmpty()) {

			final TreeNode<?, ?, V, ?> 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<? extends C> autoChildNodeType(final Class<? extends TreeNode> 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<? extends TreeNode>) superType);

		}

	}

	@SuppressWarnings("unchecked")

	protected <X> X getRawType(final Type type) {

		if (type instanceof ParameterizedType)

			return (X) ((ParameterizedType) type).getRawType();

		return (X) type;

	}

	public List<C> getChildren() {

		return children;

	}

	public void setChildren(final List<C> 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");

	}

}

package eu.dnetlib.miscutils.hstree;

/**

 * This is the terminator node in a tree definition chain:

 * 

 * TreeNode<L0, L1, TreeNode<L1, L2, TreeNode<L2, Void, NilTreeNode>>>

 * 

 * Note the use of "Void" as the next-resource-parameter value in the last level.

 * 

 * 

 * @author marko

 * 

 */

abstract public class NilTreeNode<V> extends TreeNode<Void, Void, V, TreeNode<Void, ?, V, ?>> { // NOPMD

}

package eu.dnetlib.miscutils.datetime;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Locale;

/**

 * various date utilities.

 * 

 * @author michele

 * 

 */

public class DateUtils {

	private static final SimpleDateFormat ISO8601FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.US);

	private transient final Date date;

	public DateUtils() {

		this.date = new Date();

	}

	public DateUtils(final Date date) {

		this.date = (Date) date.clone();

	}

	public String getDateAsISO8601String() {

		String result;

		synchronized (ISO8601FORMAT) {

			result = ISO8601FORMAT.format(this.date);

		}

		//convert YYYYMMDDTHH:mm:ss+HH00 into YYYYMMDDTHH:mm:ss+HH:00

		//- note the added colon for the Timezone

		return result.substring(0, result.length() - 2) + ":" + result.substring(result.length() - 2);

	}

	public Long getPrecisionTime() {

		return this.date.getTime();

	}

	public static long now() {

		return new Date().getTime();

	}

	public static String now_ISO8601() { // NOPMD

		String result;

		synchronized (ISO8601FORMAT) {

			result = ISO8601FORMAT.format(new Date());

		}

		//convert YYYYMMDDTHH:mm:ss+HH00 into YYYYMMDDTHH:mm:ss+HH:00

		//- note the added colon for the Timezone

		return result.substring(0, result.length() - 2) + ":" + result.substring(result.length() - 2);

	}

	/**

	 * parses a iso8601 date into a date.

	 * 

	 * @param date

	 *            string iso8601 date

	 * @return date object

	 */

	public Date parse(final String dateArg) {

		String date = dateArg;

		if ("".equals(date))

			return null;

		try {

			if (date.endsWith("Z")) {

				date = date.replace("Z", "+0000");

			} else if (date.length() < 20) {

				date += "+0000"; // NOPMD

			} else {

				final String end = date.substring(date.length() - 3);

				date = date.substring(0, date.length() - 3) + end.replace(":", "");

			}

			synchronized (ISO8601FORMAT) {

				return ISO8601FORMAT.parse(date);

			}

		} catch (ParseException e) {

			throw new IllegalStateException("invalid iso8601 date '" + dateArg + "' (even after normalizing it to '" + date + "')");

		}

	}

	public static String calculate_ISO8601(long l) {

		String result = ISO8601FORMAT.format(new Date(l));

		// convert YYYYMMDDTHH:mm:ss+HH00 into YYYYMMDDTHH:mm:ss+HH:00

		//- note the added colon for the Timezone

		result = result.substring(0, result.length() - 2) + ":" + result.substring(result.length() - 2);

		return result;

	}

	/**

	 * Extracts the duration part of a ISO8601 formatted date. Duration part is the part after the 'T'.

	 * 

	 * @param dateArg

	 * @return

	 */

	public String getDuration(final String dateArg) {

		String[] splitted = dateArg.split("T");

		if (splitted.length == 1)

			return "0";

		else

			return splitted[1];

	}

}

package eu.dnetlib.miscutils.datetime;

/*

 * HumanTime.java

 * 

 * Created on 06.10.2008

 * 

 * Copyright (c) 2008 Johann Burkard (<mailto:jb@eaio.com>) <http://eaio.com>

 * 

 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated

 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to the following conditions:

 * 

 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the

 * Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 * 

 */

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectOutput;

import java.util.Iterator;

/**

 * HumanTime parses and formats time deltas for easier reading by humans. It can format time information without losing

 * information but its main purpose is to generate more easily understood approximations. <h3>Using HumanTime</h3>

 * <p>

 * Use HumanTime by creating an instance that contains the time delta ({@link HumanTime#HumanTime(long)}), create an

 * empty instance through ({@link HumanTime#HumanTime()}) and set the delta using the {@link #y()}, {@link #d()},

 * {@link #h()}, {@link #s()} and {@link #ms()} methods or parse a {@link CharSequence} representation (

 * {@link #eval(CharSequence)}). Parsing ignores whitespace and is case insensitive.

 * </p>

 * <h3>HumanTime format</h3>

 * <p>

 * HumanTime will format time deltas in years ("y"), days ("d"), hours ("h"), minutes ("m"), seconds ("s") and

 * milliseconds ("ms"), separated by a blank character. For approximate representations, the time delta will be round up

 * or down if necessary.

 * </p>

 * <h3>HumanTime examples</h3>

 * <ul>

 * <li>HumanTime.eval("1 d 1d 2m 3m").getExactly() = "2 d 5 m"</li>

 * <li>HumanTime.eval("2m8d2h4m").getExactly() = "8 d 2 h 6 m"</li>

 * <li>HumanTime.approximately("2 d 8 h 20 m 50 s") = "2 d 8 h"</li>

 * <li>HumanTime.approximately("55m") = "1 h"</li>

 * </ul>

 * <h3>Implementation details</h3>

 * <ul>

 * <li>The time delta can only be increased.</li>

 * <li>Instances of this class are thread safe.</li>

 * <li>Getters using the Java Beans naming conventions are provided for use in environments like JSP or with expression

 * languages like OGNL. See {@link #getApproximately()} and {@link #getExactly()}.</li>

 * <li>To keep things simple, a year consists of 365 days.</li>

 * </ul>

 * 

 * @author <a href="mailto:jb@eaio.com">Johann Burkard</a>

 * @version $Id: HumanTime.java 323 2008-10-08 19:06:22Z Johann $

 * @see #eval(CharSequence)

 * @see #approximately(CharSequence)

 * @see <a href="http://johannburkard.de/blog/programming/java/date-formatting-parsing-humans-humantime.html">Date

 *      Formatting and Parsing for Humans in Java with HumanTime</a>

 */

public class HumanTime implements Externalizable, Comparable<HumanTime>, Cloneable {

	/**

	 * The serial version UID.

	 */

	private static final long serialVersionUID = 5179328390732826722L;

	/**

	 * One second.

	 */

	private static final long SECOND = 1000;

	/**

	 * One minute.

	 */

	private static final long MINUTE = SECOND * 60;

	/**

	 * One hour.

	 */

	private static final long HOUR = MINUTE * 60;

	/**

	 * One day.

	 */

	private static final long DAY = HOUR * 24;

	/**

	 * One year.

	 */

	private static final long YEAR = DAY * 365;

	/**

	 * Percentage of what is round up or down.

	 */

	private static final int CEILING_PERCENTAGE = 15;

	/**

	 * Parsing state.

	 */

	static enum State {

		NUMBER, IGNORED, UNIT

	}

	static State getState(char c) {

		State out;

		switch (c) {

		case '0':

		case '1':

		case '2':

		case '3':

		case '4':

		case '5':

		case '6':

		case '7':

		case '8':

		case '9':

			out = State.NUMBER;

			break;

		case 's':

		case 'm':

		case 'h':

		case 'd':

		case 'y':

		case 'S':

		case 'M':

		case 'H':

		case 'D':

		case 'Y':

			out = State.UNIT;

			break;

		default:

			out = State.IGNORED;

		}

		return out;

	}

	/**

	 * Parses a {@link CharSequence} argument and returns a {@link HumanTime} instance.

	 * 

	 * @param s

	 *            the char sequence, may not be <code>null</code>

	 * @return an instance, never <code>null</code>

	 */

	public static HumanTime eval(final CharSequence s) {

		HumanTime out = new HumanTime(0L);

		int num = 0;

		int start = 0;

		int end = 0;

		State oldState = State.IGNORED;

		for (char c : new Iterable<Character>() {

			/**

			 * @see java.lang.Iterable#iterator()

			 */

			@Override

			public Iterator<Character> iterator() {

				return new Iterator<Character>() {

					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.

	 * <p>

	 * Equivalent to <code>eval(in).getExactly()</code>

	 * 

	 * @param in

	 *            the char sequence, may not be <code>null</code>

	 * @return a formatted String, never <code>null</code>

	 */

	public static String exactly(CharSequence in) {

		return eval(in).getExactly();

	}

	/**

	 * Formats the given time delta, preserving all data.

	 * <p>

	 * Equivalent to <code>new HumanTime(in).getExactly()</code>

	 * 

	 * @param l

	 *            the time delta

	 * @return a formatted String, never <code>null</code>

	 */

	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.

	 * <p>

	 * Equivalent to <code>eval(in).getApproximately()</code>

	 * 

	 * @param in

	 *            the char sequence, may not be <code>null</code>

	 * @return a formatted String, never <code>null</code>

	 */

	public static String approximately(CharSequence in) {

		return eval(in).getApproximately();

	}

	/**

	 * Formats the given time delta, preserving all data.

	 * <p>

	 * Equivalent to <code>new HumanTime(l).getApproximately()</code>

	 * 

	 * @param l

	 *            the time delta

	 * @return a formatted String, never <code>null</code>

	 */

	public static String approximately(long l) {

		return new HumanTime(l).getApproximately();

	}

	/**

	 * The time delta.

	 */

	private long delta;

	/**

	 * No-argument Constructor for HumanTime.

	 * <p>

	 * Equivalent to calling <code>new HumanTime(0L)</code>.

	 */

	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 <code>null</code>

	 */

	public String getExactly() {

		return getExactly(new StringBuilder()).toString();

	}

	/**

	 * Appends a human-formatted representation of the time delta to the given {@link Appendable} object.

	 * 

	 * @param <T>

	 *            the return type

	 * @param a

	 *            the Appendable object, may not be <code>null</code>

	 * @return the given Appendable object, never <code>null</code>

	 */

	public <T extends Appendable> 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 <code>null</code>

	 */

	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 <T>

	 *            the return type

	 * @param a

	 *            the Appendable object, may not be <code>null</code>

	 * @return the given Appendable object, never <code>null</code>

	 */

	public <T extends Appendable> 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.

	 * <p>

	 * The output is identical to {@link #getExactly()}.

	 * 

	 * @see java.lang.Object#toString()

	 * @see #getExactly()

	 * @return a String, never <code>null</code>

	 */

	@Override

	public String toString() {

		return getExactly();

	}

	/**

	 * Compares this HumanTime to another HumanTime.

	 * 

	 * @param t

	 *            the other instance, may not be <code>null</code>

	 * @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);

	}

}

package eu.dnetlib.miscutils.iterators.xml;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.nio.charset.Charset;

import java.util.Iterator;

public class IterableXmlParser implements Iterable<String> {

	private String element;

	private InputStream inputStream;

	public IterableXmlParser(String element, InputStream inputStream) {

		this.element = element;

		this.inputStream = inputStream;

	}

	public IterableXmlParser(String element, String xml) {

		this.element = element;

		this.inputStream = new ByteArrayInputStream(xml.getBytes(Charset.forName(XMLIterator.UTF_8)));

	}

	@Override

	public Iterator<String> iterator() {

		return new XMLIterator(element, inputStream);

	}

}

package eu.dnetlib.miscutils.iterators.xml;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.StringWriter;

import java.nio.charset.Charset;

import java.nio.charset.CharsetDecoder;

import java.nio.charset.CodingErrorAction;

import java.util.Iterator;

import javax.xml.stream.XMLEventFactory;

import javax.xml.stream.XMLEventReader;

import javax.xml.stream.XMLEventWriter;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLOutputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.events.StartElement;

import javax.xml.stream.events.XMLEvent;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class XMLIterator implements Iterator<String> {

	private static final Log log = LogFactory.getLog(XMLIterator.class);

	private ThreadLocal<XMLInputFactory> inputFactory = new ThreadLocal<XMLInputFactory>() {

		@Override

		protected XMLInputFactory initialValue() {

			return XMLInputFactory.newInstance();

		}

	};

	private ThreadLocal<XMLOutputFactory> outputFactory = new ThreadLocal<XMLOutputFactory>() {

		@Override

		protected XMLOutputFactory initialValue() {

			return XMLOutputFactory.newInstance();

		}

	};

	private ThreadLocal<XMLEventFactory> eventFactory = new ThreadLocal<XMLEventFactory>() {

		@Override

		protected XMLEventFactory initialValue() {

			return XMLEventFactory.newInstance();

		}

	};

	public static final String UTF_8 = "UTF-8";

	final XMLEventReader parser;

	private XMLEvent current = null;

	private String element;

	private InputStream inputStream;

	public XMLIterator(final String element, final InputStream inputStream) {

		super();

		this.element = element;

		this.inputStream = inputStream;

		this.parser = getParser();

		try {

			this.current = findElement(parser);

		} catch (XMLStreamException e) {

			log.warn("cannot init parser position. No element found: " + element);

			current = null;

		}

	}

	@Override

	public boolean hasNext() {

		return current != null;

	}

	@Override

	public String next() {

		String result = null;

		try {

			result = copy(parser);

			current = findElement(parser);

			return result;

		} catch (XMLStreamException e) {

			throw new RuntimeException(String.format("error copying xml, built so far: '%s'", result), e);

		}

	}

	@Override

	public void remove() {

		throw new UnsupportedOperationException();

	}

	@SuppressWarnings("finally")

	private String copy(final XMLEventReader parser) throws XMLStreamException {

		final StringWriter result = new StringWriter();

		try {

			final XMLEventWriter writer = outputFactory.get().createXMLEventWriter(result);

			final StartElement start = current.asStartElement();

			final StartElement newRecord = eventFactory.get().createStartElement(start.getName(), start.getAttributes(), start.getNamespaces());

			// new root record

			writer.add(newRecord);

			// copy the rest as it is

			while (parser.hasNext()) {

				final XMLEvent event = parser.nextEvent();

				// TODO: replace with depth tracking instead of close tag tracking.

				if (event.isEndElement() && event.asEndElement().getName().getLocalPart().equals(element)) {

					writer.add(event);

					break;

				}

				writer.add(event);

			}

			writer.close();

		} finally {

			return result.toString();

		}

	}

	/**

	 * Looks for the next occurrence of the splitter element.

	 *

	 * @param parser

	 * @return

	 * @throws XMLStreamException

	 */

	private XMLEvent findElement(final XMLEventReader parser) throws XMLStreamException {

		/*

		 * if (current != null && element.equals(current.asStartElement().getName().getLocalPart())) { return current; }

		 */

		XMLEvent peek = parser.peek();

		if (peek != null && peek.isStartElement()) {

			String name = peek.asStartElement().getName().getLocalPart();

			if (element.equals(name)) { return peek; }

		}

		while (parser.hasNext()) {

			final XMLEvent event = parser.nextEvent();

			if (event != null && event.isStartElement()) {

				String name = event.asStartElement().getName().getLocalPart();

				if (element.equals(name)) { return event; }

			}

		}

		return null;

	}

	private XMLEventReader getParser() {

		try {

			return inputFactory.get().createXMLEventReader(sanitize(inputStream));

		} catch (XMLStreamException e) {

			throw new RuntimeException(e);

		}

	}

	private Reader sanitize(final InputStream in) {

		final CharsetDecoder charsetDecoder = Charset.forName(UTF_8).newDecoder();

		charsetDecoder.onMalformedInput(CodingErrorAction.REPLACE);

		charsetDecoder.onUnmappableCharacter(CodingErrorAction.REPLACE);

		return new InputStreamReader(in, charsetDecoder);

	}

}

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 <T>

 */

public class IterableIterator<T> implements Iterable<T> {

        private Iterator<T> iter;

        public IterableIterator(Iterator<T> iter) {

                this.iter = iter;

        }

        @Override

		public Iterator<T> iterator() {

                return iter;

        }

}

package eu.dnetlib.miscutils.iterators;

import java.util.Iterator;

import java.util.List;

import eu.dnetlib.miscutils.collections.Pair;

public class IterablePair <A, B> implements Iterable<Pair<A, B>> {

    private final List<A> first;

    private final List<B> second;

    public IterablePair(List<A> first, List<B> second) { 

        this.first = first;

        this.second = second;

    }

    @Override

    public Iterator<Pair<A, B>> iterator() {

        return new ParallelIterator<A, B>(first.iterator(), second.iterator());

    }

}